Edge Collective
E-Ink Map Display Prototyping
Setting up a (low power?) E-Ink display with a micro2020 Nov 09
Youtube tutorial by Techiesms
Nice tutorial using ESP32 and 4.2 " e-ink display
Associated library, GxEPD is here
Link for project code in the tutorial is here
 |
|---|
| Heltec Wifi LoRa v2 pinout. |
Instructions for Adafruit MicroSD are here.
Formatting a microSD tutorial here
Convert to byte array code here
converting input images to proper grayscale here
this conversion pipeline looks great -- here
which is explained along with other code here
Working code, SD card to itsym0 4.2 in e-ink
Code on github is here
Converting images
Great little tutorial here
convert Lenna.png -monochrome lenna-1.png
convert lenna.png -monochrome -resize 200x320\! lenna4.bmp
Compass
Good quality compass offered here
Map tiles
Typical map tile size is 256x265 -- reference here
Guide to creating your own tiles here
Browsing local tiles guide here <---- this seems like a great guide to dive into.
More basic guide to OSM tiles here.
PCB Antennas for GPS
Guide here
Design considerations for UBlox here
 |
|---|
| Fig 9 from the UBlox App Note mentioned above. |
Offline maps
Nice discussion and review here
Open Map Tiles
Main project description is here.
Open map tiles project update is here
OMT is compatible with Stamen's Toner -- post here.
Grayscale / B&W image
Thread discussion here.
Doing it without dithering:
convert bone.png -colorspace gray -threshold 80% -type bilevel -resize 200x320\! bone4.bmp
Caltopo
E-Ink setup
Link to waveshare guide for 4.2 in e-ink here
Datasheet is here.
ESP32 Low-power modes
There's a nice description here.
Tutorial on using ESP32 deep sleep here.
In particular, wakeup from external pin here.
Low-power ESP32:
-
E-Pulse project is [here](https://thingpulse.com/product/epulse-low-power-esp32-development-board/#:~:text=ePulse%2C%20the%20low%20power%20ESP32,and%2035uA%20(at%2012V).
Eink experiments
Inspiring projects
Arduino APRS project, here.
Key project. Marinus, and APRS display project, here. Great set of links, here!
Online code to generate OSM tiles for download is here.
Ham Radio for Arduino and Picaxe book --- Description, Amazon.
Source code for generating tiles from OSM is here
Grid square locator on above site is broken; perhaps this works?
Grid square locator here.
Computing lat / lon here.
Conant road lat / lon: 42.41158 -71.2983
Grid square utility here works, but doesn't give 10 character grid squares ...
Another tool is here, which generates a nice overlay ... <-- this is the tool to use!
So, the combined tools are:
- identifying your grid square in ham radio, here.
- using a python script to grab the tiles, here -- seems to be broken.
Example grid square:
FN42IK44LP
Grid Squares
Generator here. Uses a nice open source geocoding app that works with OSM. The author, ha8tks, has a repo on github that applies the GridSquare layout in Leaflet.
Reference on gridsquares here
Ham radio chat on grid squares here.
General term for this is the Maidenhead Gridsquare System.
(Alternative: the World Geodetic System)
Nice explanation of the grid locator system.
Nice historical background on the system.
Really nice video explanation of grid squares.
OSM Tiles
Guide to tiles here.
Tutorial on how to use OSM tiles in an application, here.
Leaflet providers here <-- really useful survey of free tile providers.
Good list of hiking maps
2020-11-25 10:50:31
Would be nice to include the GridSquare system in an offline map. Easily switch between a device and a paper printout.
How would one overlap on a 'regular' map? Might be neat to try to do via features. Would need same project I suppose.
Note that there's a TTGO EINK+ESP32 module here.
E-ink calendar display project here for ESP32.
Quick tally of hardware costs
If custom board:
- pcb: $10
- display: $30
- gps: $5
- micro+passives: $5
- misc: $5
- total: $55
can sell for 4X to support project, or around $200?
If DIY kit:
- pcb: $10
- display: $30
- microcontroller: $20
- SD card: $5
- GPS: $5
Can sell the PCB + SD card + GPS + screen as a kit for (10+30+5+5)*4 = $200 ... hmm. Maybe if also sell a case ...
GPS
Sparkfun ublox library.
Various Sparkfun ublox products.
I think the cheap chip vis a vis ublox is the NEO-6M. That's on the meshtastic, and that's what I'm using via Amazon. E.g. here.
This is the 'NEO-6M' item I've been using, here.
Designing a PCB for the waveshare
Module description is here.
Dimensions of module are thus:
Sparfkun thumb slide joystick.
Two-axis analog thumb joystick from adafruit.
2021-02-14 11:23:13
Interesting thread on plus codes, MRGR, etc -- https://news.ycombinator.com/item?id=18646485
The nicest viz of the map: https://dxcluster.ha8tks.hu/hamgeocoding/
2021-02-27 16:30:18
Note that there is a new GxEPD library -- GxEPD2 -- should check it out!
2021-03-17 11:41:44
Nice article on hiking and mapping: https://blog.mapillary.com/community/2017/04/07/mapping-hiking-routes-openstreetmap-mapillary.html
2021-03-17 11:44:27
Leaflet trails plugin here: https://github.com/Raruto/leaflet-trails
2021-03-17 12:01:19
From Dave S.:
Minimalist display lib:
The library I used is the lcdgfx library which should be right in the list of Arduino libraries.
Here's the code. As you can see, the interface to it is quite different than the standard 1306 library. You do a display.fill to clear the display and then use the display.printFixed function to write strings at a specific row/column location (those coordinates are in pixels with column followed by row. I'll put the whole code below but here are the include and some of the display functions I used in setup() to show an startup message:
#include "lcdgfx.h"
DisplaySSD1306_128x64_I2C display(-1); // This line is suitable for most platforms by default
setup() {
display.setFixedFont( ssd1306xled_font6x8 );
display.begin();
display.fill(0x00);
display.setFixedFont(ssd1306xled_font6x8);
display.printFixed (0, 8, "Starting...", STYLE_NORMAL);
}
Here's the full sketch:
----------------------------------
#include <LowPower.h>
#include <SPI.h>
#include <Wire.h>
#include <RH_RF95.h>
#include "lcdgfx.h"
#include <SoftwareSerial.h>
SoftwareSerial Serial1(3, 4); // RX, TX
DisplaySSD1306_128x64_I2C display(-1); // This line is suitable for most platforms by default
// radio pins for mothbot
#define RFM95_CS 8
#define RFM95_RST 7
#define RFM95_INT 2
// Change to 434.0 or other frequency, must match RX's freq!
#define RF95_FREQ 434.0
// Singleton instance of the radio driver
RH_RF95 rf95(RFM95_CS, RFM95_INT);
#define LED 14
void types(String a) { Serial.println("it's a String"); }
void types(int a) { Serial.println("it's an int"); }
void types(char *a) { Serial.println("it's a char*"); }
void types(float a) { Serial.println("it's a float"); }
void types(bool a) { Serial.println("it's a bool"); }
void setup()
{
pinMode(LED, OUTPUT);
pinMode(RFM95_RST, OUTPUT);
digitalWrite(RFM95_RST, HIGH);
Serial.begin(115600);
// while (!Serial) {
// delay(1);
// }
Serial1.begin(9600);
delay(100);
display.setFixedFont( ssd1306xled_font6x8 );
display.begin();
display.fill(0x00);
display.setFixedFont(ssd1306xled_font6x8);
display.printFixed (0, 8, "Starting...", STYLE_NORMAL);
Serial.println("Starting...");
// display.printFixed (0, 16, "Line 2. Bold text", STYLE_BOLD);
// display.printFixed (0, 24, "Line 3. Italic text", STYLE_ITALIC);
// display.printFixedN (0, 32, "Line 4. Double size", STYLE_BOLD, FONT_SIZE_2X);
delay(1000);
// manual reset
digitalWrite(RFM95_RST, LOW);
delay(10);
digitalWrite(RFM95_RST, HIGH);
delay(10);
while (!rf95.init()) {
Serial.println(F("LoRa radio init failed"));
Serial.println(F("Uncomment '#define SERIAL_DEBUG' in RH_RF95.cpp for detailed debug info"));
while (1);
}
Serial.println(F("LoRa radio init OK!"));
// Defaults after init are 434.0MHz, modulation GFSK_Rb250Fd250, +13dbM
if (!rf95.setFrequency(RF95_FREQ)) {
Serial.println(F("setFrequency failed"));
while (1);
}
Serial.print(F("Set Freq to: ")); Serial.println(RF95_FREQ);
// Defaults after init are 434.0MHz, 13dBm, Bw = 125 kHz, Cr = 4/5, Sf = 128chips/symbol, CRC on
// The default transmitter power is 13dBm, using PA_BOOST.
// If you are using RFM95/96/97/98 modules which uses the PA_BOOST transmitter pin, then
// you can set transmitter powers from 5 to 23 dBm:
rf95.setTxPower(5, false);
}
int16_t packetnum = 0; // packet counter, we increment per xmission
void loop()
{
//LowPower.idle(SLEEP_8S, ADC_OFF, TIMER2_OFF, TIMER1_OFF, TIMER0_OFF,
// SPI_OFF, USART0_OFF, TWI_OFF);
// LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);
int start_time = millis();
// read battery voltage and convert to 10ths of volts
int voltsX10 = round(10* 2 * 3.3 *analogRead(A3)/1023);
voltsX10=25; // *** REMOVE THIS WHEN BATTERY USED ***
// read temp/humid/press
int countBuffer = 0;
// Empty the software serial buffer
while (Serial1.available()) {
Serial1.read();
countBuffer++;
}
Serial.print(F("Cleared Buffer: "));
Serial.println(countBuffer);
// wait for an R
while (!Serial1.available() || Serial1.read() != 'R')
{
//Wait for an 'R' that significes the start of a message
// from the Maxbotix
}
//Read the distance measurement
char buff[5]=" ";
int count = 0;
while (count < 4) {
char c = Serial1.read();
if (int(c) == -1) {
continue;
}else {
buff[count] = c;
count++;
}
}
buff[4] = 0;
display.fill(0x00);
digitalWrite(LED, HIGH);
delay(5);
digitalWrite(LED, LOW);
char radiopacket[25] = "D";
//itoa(packetnum, radiopacket + 13, 10);
strcat(radiopacket, buff);
strcat(radiopacket, "mm");
char voltStr[3];
itoa(voltsX10, voltStr, 10);
strcat(radiopacket, voltStr);
strcat(radiopacket, "v");
char seq[2];
itoa(packetnum%10, seq, 10);
strcat(radiopacket, seq);
packetnum++;
Serial.print(F("Sending Msg: "));
Serial.println(radiopacket);
delay(10);
display.printFixed (0, 0, "Sending...", STYLE_NORMAL);
display.printFixed (0, 8, radiopacket, STYLE_NORMAL);
radiopacket[19] = 0;
rf95.send((uint8_t *)radiopacket, 20);
delay(10);
rf95.waitPacketSent();
// Now wait for a reply
uint8_t buf[RH_RF95_MAX_MESSAGE_LEN];
uint8_t len = sizeof(buf);
if (rf95.waitAvailableTimeout(1000))
{
// Should be a reply message for us now
if (rf95.recv(buf, &len))
{
// delay(500);
digitalWrite(LED, HIGH);
delay(5);
digitalWrite(LED, LOW);
display.printFixed (0, 24, "Reply:", STYLE_NORMAL);
display.printFixed (0, 36, (char*)buf, STYLE_NORMAL);
display.printFixed (0, 48, "RSSI:", STYLE_NORMAL);
char rs[5];
itoa(rf95.lastRssi(), rs,10);
display.printFixed (40, 48, rs, STYLE_NORMAL);
digitalWrite(LED, LOW);
}
else
{
Serial.println(F("Receive failed"));
}
}
else
{
Serial.println(F("No reply, is there a listener around?"));
display.printFixed (0, 24, "No Reply", STYLE_NORMAL);
display.printFixed (0, 36, "Anyone There?", STYLE_NORMAL);
}
delay(1000);
display.fill(0x00);
delay(8000);
int end_time = millis();
Serial.print(F("Loop duration: "));Serial.println(end_time - start_time);
}
Article comparing libraries: https://www.best-microcontroller-projects.com/ssd1306.html
2021-03-17 12:12:23
Nice overview of leaflet layers: https://leaflet-extras.github.io/leaflet-providers/preview/
Another implementation of Maidenhead in Leaflet: https://gitlab.com/IvanSanchez/leaflet.maidenhead
Nice explanation of the gridsquare formula here: https://ham.stackexchange.com/questions/221/how-can-one-convert-from-lat-long-to-grid-square
Way of converting code to the bounds of the square here: https://ham.stackexchange.com/questions/6114/convert-maidenhead-grid-square-to-lat-long-in-excel
lat: =(CODE(MID(A1,2,1))-65)*10 + VALUE(MID(A1,4,1)) + (CODE(MID(A1,6,1))-97)/24 + 1/48 - 90
lon: =(CODE(MID(A1,1,1))-65)*20 + VALUE(MID(A1,3,1))*2 + (CODE(MID(A1,5,1))-97)/12 + 1/24 - 180
2021-03-18 16:38:49
Working version of mothboth trip here: https://github.com/edgecollective/mothbot-trip/tree/2183b1aae56f516f98a047230a68cd2553ea982e/ver_0.1-alpha/mothbot_getLoc
2021-03-18 17:29:40
Bayou with gridsquares: https://gitlab.com/p-v-o-s/agroeco/bayou/-/tree/34ef9184bed1363f8898ec28e746165d1d451f58
Mothbot w/ gridsquares: https://github.com/edgecollective/mothbot-trip/tree/bb1cc43d0a44d89632f710a618f8f8e894ab33a2
2021-03-18 17:43:02
Working url for bayou w/ gridsquares for now: http://192.168.1.163:5000/data/srercz3pjhsu/gridsquare/2
2021-03-19 13:39:45
1.54 in e-ink -- ali express
2021-03-19 16:54:40
SSD1306 power saving -- https://forum.arduino.cc/index.php?topic=565996.0
Article on OLED with powersave: https://bengoncalves.wordpress.com/2015/10/01/oled-display-and-arduino-with-power-save-mode/
2021-03-19 21:16:33
Added a gridsquare demo repo codebase here:
https://github.com/edgecollective/leaflet-gridsquare
2021-03-20 11:27:36
Gps sleep for NEO-6M -- https://forum.arduino.cc/index.php?topic=497410.0
Sending sleep command to Adafruit GPS https://forums.adafruit.com/viewtopic.php?f=19&t=28121
Really great thread here: GPS sleep mode described here: https://forums.adafruit.com/viewtopic.php?f=31&p=547903
2021-03-20 11:45:37
Distances, deg minute sec https://www.usgs.gov/faqs/how-much-distance-does-a-degree-minute-and-second-cover-your-maps?qt-news_science_products=0#qt-news_science_products
2021-03-21 11:10:33
e-ink feather friend https://learn.adafruit.com/assets/86035
selection guide -- https://www.amazon.com/Waveshare-Resolution-Electronic-Controller-Three-Color/dp/B074P3LWJQ/ref=sr_1_3?dchild=1&keywords=1.54+in+eink+raw&qid=1616340057&sr=8-3
black and white e-ink supports partial refresh, can refresh in 2 sec rather than 8 sec ...
sparkfun ublox library https://github.com/sparkfun/SparkFun_u-blox_GNSS_Arduino_Library
adafruit gfx library https://learn.adafruit.com/adafruit-gfx-graphics-library/graphics-primitives
2021-03-22 09:50:48
advantages of e-ink https://www.electronicdesign.com/technologies/embedded-revolution/article/21805149/11-myths-about-epaper-displays
UTM method for topographic maps https://www.usgs.gov/faqs/what-does-term-utm-mean-utm-better-or-more-accurate-latitudelongitude?qt-news_science_products=0#qt-news_science_products
exploring options for diy waterproofing https://hackaday.com/2017/12/26/exploring-options-for-diy-waterproofing/
2021-03-24 10:48:02
https://github.com/noopkat/avrgirl-arduino
https://github.com/spaceneedle/Chromeduino
http://meow.noopkat.com/the-avrgirl-project-an-introduction/
https://chrome.google.com/webstore/detail/avrchick/kpbgbcocfgjbmnpplcjlcammjdkgogba?hl=en
https://github.com/noopkat/oled-js
https://github.com/avrxml/AS6-Devices-XML/blob/master/ATmega1284P.xml
http://archive.fabacademy.org/2016/fablabkamplintfort/students/125/exercise14.html
compiled .hex using arduino ideo for 1284p
boards.js of avrgirl-arduino:
(pretty sure pageSize is correct; not sure about numPages ... just trying to get to 128K )
{
name: '1284p',
baud: 115200,
signature: Buffer.from([0x1e, 0x97, 0x05]),
pageSize: 256,
numPages: 500,
timeout: 400,
//productId: ['0x0043', '0x7523', '0x0001', '0xea60', '0x6015'],
//productPage: 'https://store.arduino.cc/arduino-uno-rev3',
protocol: 'stk500v1'
},
command:
node cli.js flash -f Blink_1284.hex -a 1284p -p /dev/ttyUSB0
2021-03-24 13:20:30
reading software serial RX as pin 13 on 128p4.
2021-03-24 13:50:33
neo 6m sleep:
The t-beam gps chip (Neo-6m) can be put into sleep by commisioning a power save command using proprietary UBX protocol over Neo's RX TX pins. In normal mode of operation the chip sends out location using NMEA protocol. Switching between these protocols can be done via pin 14 and 15 (see Data Sheet 1.15). However, as can be seen in the image below, these pins are not connected on the T-beam. During testing is established that the Neo does execute UBX commands in NMEA mode but does not send back acknowledgements. Therefore UBX commands, such as the sleep command, that do not require acknowledgements work out of the box. Nonetheless, protocols switching pins 14 and 15 are exposed on the t-beam. Thus the pins could be soldered to two GPIO pins by hand. By connectings these pins UBX acknowledgements could be enabled, this is however not an necessity.
analyzing neo6m module http://forum.espruino.com/conversations/332295/
nice video on setup for neo 6m https://www.youtube.com/watch?v=pHu2yvsFFgw
power saving for ublox https://ukhas.org.uk/guides:ublox_psm <-- this is the relevant guide!
https://github.com/MCUdude/MightyCore
https://hackaday.io/project/25677-chirppp-serial-over-lora serial over lora
2021-03-25 08:31:45
Mightyduino https://www.eevblog.com/forum/projects/mightyduino-diy-arduino-with-atmega644patmega1284p/
-- 6ft 3 pack usb to barrel jack https://www.amazon.com/3-Pack-2-1mm-Power-Barrel-Connector/dp/B07JGR7JJQ/ref=sr_1_3?dchild=1&keywords=5.5x2.1+mm+usb&qid=1616687264&s=industrial&sr=1-3
SRAM chip to place https://www.digikey.com/en/products/detail/microchip-technology/23K256-I-SN/2001113
standby current: 4 uA
breakout for max m8q -- https://store.uputronics.com/index.php?route=product/product&product_id=84
sam m8q datasheet https://www.u-blox.com/en/docs/UBX-16012619
WOAH:
clone of adafruit featherwing using sam m8q https://github.com/PaulZC/SAM-M8Q_GPS_FeatherWing/blob/master/LEARN.md
clone of adafruti featherwing using max m8q https://github.com/PaulZC/MAX-M8Q_GPS_FeatherWing
interesting projects from paulzc https://github.com/PaulZC?tab=repositories
hookup guide for sam m8q https://learn.sparkfun.com/tutorials/sparkfun-gps-breakout-zoe-m8q-and-sam-m8q-hookup-guide/all
2021-03-25 14:30:50
gps basics written by sparkfun https://learn.sparkfun.com/tutorials/gps-basics
sam m8q breakout from sparkun schematic: https://cdn.sparkfun.com/assets/3/c/2/2/e/SparkFun_Ublox_SAM-M8Q.pdf
sam m8q feather wing schematic: https://github.com/PaulZC/SAM-M8Q_GPS_FeatherWing/blob/master/SAM-M8Q_GPS_FeatherWing.pdf
En is a true 'power disable' control line you can use to completely cut power to the SAM-M8Q. This is good if you need to run at ultra-low-power modes. By default this is pulled low (enabled). So pull high (to 3V) to disable the SAM-M8Q.
data on hot start / warm start neo 6m: https://portal.u-blox.com/s/question/0D52p00008HKEEpCAP/i-have-been-using-a-neo-6m-how-do-i-ensure-that-it-always-performs-a-hot-start-every-time-it-powers-up
p channel mosfet
https://www.digikey.com/en/products/detail/diodes-incorporated/DMG3415U-7/2052768
eink friend schematic https://cdn-learn.adafruit.com/assets/assets/000/057/645/original/adafruit_products_schem.png?1531712746
2021-03-26 19:41:58
eink feather friend: https://cdn-learn.adafruit.com/assets/assets/000/086/035/original/adafruit_products_Feather_eInk_Friend_sch.png?1576774972
https://hackaday.com/2015/07/24/it-keeps-on-going-and-arduino-edition/
70 μA is a huge amount of current for a sleeping microcontroller. In a well-designed system, sleep currents under 1μA should be quite possible. I haven’t watched the whole video, but here are some general strategies, in no particular order:
* Turn off all unnecessary clocks, and run necessary clocks as slow as possible while sleeping. If you can get by with just waking up on an external interrupt, all clocks can be off while asleep. If you need to wake up periodically, use a low-power RC oscillator (like the one for the watchdog timer on the mega328p). When powered on, there is a tradeoff: a faster clock requires more power, but means that the work can be finished and the chip can go back to sleep sooner.
* Use the power reduction registers to turn off all unused peripherals all the time, and used peripherals when they are not needed, especially if there isn’t a long reinitialization time when powering them back on.
* Turn on the pull-up resistors on all unused GPIO pins. If they are left floating, the inputs might flip back and forth randomly, needlessly consuming power.
* Turn off brownout detection if you can. It consumes a significant amount of power. If erratic behavior (and possible memory corruption) is intolerable when your batteries are dying, some microcontrollers have a sampled BOD mode that uses much less power. You can also implement this yourself in software with an ADC and bandgap (or other stable reference), checking your system voltage only periodically (like once a day) and shutting down before it gets too low.
* Voltage dividers, like the one for the photocell in this project, consume power—current flows from power to ground through the two series resistors. Size the resistors as large as practically possible, and bias the voltage divider with a GPIO pin that can be turned off when the sensor is not needed rather than just tying it to Vcc.
* Voltage regulators can have significant quiescent current draw. If at all possible, power the circuit directly from batteries without a regulator. A pair of AAs, or a CR2032 coin cell are both good 3V supplies, and most microcontrollers are very happy with this. If regulators must be used, specifically choose ones with very low quiescent draw.
* Electrolytic capacitors can also have high leakage currents—avoid them in power supplies or choose low-leakage versions.
* Rechargeable batteries are generally a poor choice for long-life low power applications. Self-discharge rates can often be higher than the load of the circuit itself! Non-rechargeable lithium batteries are a good in these applications.
* Generally, less power is consumed at lower voltages, so running as low as is practical can be advantageous. However, often sensors and other devices will have higher voltage requirements than the MCU, and the complexity (and additional power draw) of translating between multiple voltages often isn’t worth it, nor is regulating down from whatever battery voltages are available (unless it’s a significant drop and you’re using good switching regulators). Depending on your battery chemistry, running at the minimum voltage might also mean that you can only run your battery down so far before you start browning out.
Instead of a transistor I prefer a (second) LDO with low quiescent current draq like the TPS 783xx with enable input. So you can power-off all external components not needed.
I do a lot of low power applications at work (with MSP, never had to handle Atmel for low power) and with the “usual” tricks you and bdm mentioned >1uA applications are no problem
So here we go, throw your AA batteries out of the desing an go with a cr2302 cell, easy as 123 :D
total supply on device needed:
- gps: 67 mA
so:
- use MCP1702/3 for main LDO
- use ap2112k-3.3 to power subcircuit
- uno might only do eink and gps
- atmega adds sd card and lora
- pinouts for other displays?
uno-based version that uses oled and gps and uno and is all dip
smt version should use SAM or CAM M8Q
2021-03-27 19:36:11
https://www.eevblog.com/forum/beginners/potting-a-battery/
Have you considered using AA batteries ?
You can get lithium based AA batteries like Energizer Ultimate Lithium that have something like 3500mAh at around 1.4v..1.7v ... see : http://data.energizer.com/pdfs/l91.pdf
They're not cheap at around 2-3$ each but it's way cheaper than your 14$ battery.
Regular alkaline AA batteries get close to 2500-2800 mAh and discharge down to around 1..1.2v
You can buy battery holders that solder to the circuit board and then you can pot everything leaving just the battery contacts on the outside. Then insert battery and use hot glue or that selastic / flexible gunk / whatever... something to lock it in the battery holder to prevent vibrations from breaking contact.
There are microcontrollers that run from battery but if you need 3v, why not just use a very efficient voltage doubler IC... would be over 95% efficient at a few mA of current.
Here's some examples:
1. TPS6031x series : 0.9v..1.8v , 2 outputs, 1: 2xVin max 40mA, 2: regulated 3.3v 20mA up to 90% efficiency : http://www.ti.com/lit/ds/symlink/tps60310.pdf
2. TPS6030x series : pretty much same thing? http://www.ti.com/lit/ds/symlink/tps60300.pdf
The above are ~ 1.7$ in 10pcs or higher and need only 5 ceramic capacitors to work. This + battery is still way cheaper than 14$
There's also very efficient switching regulators.. here's ex
<1$ / 10+ pcs TLV61225 - min 0.7v in, fixed 3.3v out, 94% efficiency, needs only 2 ceramic caps and inductor : http://www.ti.com/lit/ds/symlink/tlv61225.pdf
There's also TLV61224,
TPS61261 - min 0.8v, fixed 3.3v out or adjustable options, up to 95% efficiency, same min. parts : http://www.ti.com/lit/ds/symlink/tps61260.pdf
Even when you add the price of a surface mounted ceramic inductor and a bunch of ceramic capacitors, you're still below 2$.
There's loads of microcontrollers from Microchip that use less power and can run at lower voltages (like 1.8v..3.6v for example). There's also Silicon Labs with their BusyBee micros that can work at low voltages and they're quite nice micros.
https://www.ti.com/lit/ds/symlink/tlv61225.pdf
https://www.e-education.psu.edu/geog585/node/708
multiple spi buses in the atmega1284p https://feilipu.me/2015/02/17/avr-atmega-usart-spi-mspim/
2021-03-28 17:51:24
Rotary position switch digikey https://www.digikey.com/en/products/detail/grayhill-inc/94HBB16T/726321
nice rotary switch SMT digikey https://www.digikey.com/en/products/detail/nidec-copal-electronics/SH-7010TB/2057868
through hole, black, nice color https://www.digikey.com/en/products/detail/nidec-copal-electronics/SD-2010/948380 <---- this is the one to get!!
garmin foretex https://www.amazon.com/Garmin-010-01772-00-Foretrex-601-inches/dp/B073NXKWYN/ref=psdc_2230642011_t1_B07RTD2PMT?th=1
military grid reference system https://en.wikipedia.org/wiki/Military_Grid_Reference_System
mgrs vs maidenhead https://www.usna.edu/Users/oceano/pguth/md_help/html/mgrs_utm.htm
2021-03-29 09:10:01
2021-03-31 08:37:52
espruino discussion on nordic chip here
discussion of nrf52840 here
continued here ---
2021-03-31 09:05:26
Cave pearl post on the atmega1284p https://thecavepearlproject.org/2020/05/11/build-an-atmega-1284p-based-data-logger/
2021-03-31 09:25:20
dual screens https://thecavepearlproject.org/2020/11/15/adding-two-oled-displays-to-your-arduino-logger-with-no-library/
espruino firmware esp32 http://www.esp32learning.com/information/espruino-on-an-esp32.php
https://www.espruino.com/ESP32
2021-03-31 13:01:06
ESP32-S2 -- circuitpython -- sleep! Magtag -- [https://www.adafruit.com/product/4800][https://www.adafruit.com/product/4800]
adafruit magtag -https://www.digikey.com/catalog/en/partgroup/adafruit-magtag-2-9-grayscale-e-ink-wi-fi-display/113912
itsy bitsy bluefruit https://learn.adafruit.com/adafruit-itsybitsy-nrf52840-express
meshtastic dicussion around keyboard https://meshtastic.discourse.group/t/autonomous-device-with-q10-keyboard-and-ili9341/438/13
nice docs for lora communicator project https://github.com/manacake/docs.greycat.co/
nice github repo for blackberry keyboard https://github.com/arturo182/BBQ10KBD
blackberry q10 adafruit description https://blog.adafruit.com/2019/01/14/interfacing-a-blackberry-q10-keyboard-into-your-microcontroller-project-blackberry-arduino-microcontroller/
and arduino thread https://forum.arduino.cc/index.php?topic=355709.0
q10 keyboard on ebay https://www.ebay.com/c/1731749316
and on eevblog here https://www.eevblog.com/forum/beginners/how-to-connect-to-a-very-very-challanging-blackberry-q10-keyboard-connector/msg735622/#msg735622
stm32 bootloader vis espruino http://www.espruino.com/Serial+Bootloader
2021-03-31 17:18:40
ble uart https://learn.adafruit.com/circuitpython-ble-libraries-on-any-computer/ble-uart-example
Q10 on Ebay https://www.ebay.com/c/1731749316
nice library for ublox modules https://github.com/loginov-rocks/UbxGps
sam m8q on digikey https://www.digikey.com/en/products/detail/u-blox/SAM-M8Q-0-10/7393574 -- $25
max m8q on digikey https://www.digikey.com/en/products/detail/u-blox/MAX-M8Q-0/6150636 -- $21
ble uart https://learn.adafruit.com/bluefruit-le-connect
https://www.hackster.io/mitchwongho/read-phone-notifications-using-esp-eb0ad4
https://play.google.com/store/apps/details?id=com.lianhezhuli.btnotification
https://play.google.com/store/apps/details?id=com.lhzl.mtwearpro
2021-04-07 20:31:34
images over lora
https://github.com/javl/slowimage and -- oh goodness! https://ieeexplore.ieee.org/document/8875321 both on transmitting images via lora  and -- oooh! https://blog.adafruit.com/2020/11/24/transmitting-sound-and-image-over-a-lora-link-lora-radio/ https://github.com/bwhitman/loracamera
https://github.com/rxi/lite
https://www.oregon.gov/deq/FilterDocs/latlonginstr.pdf
https://www.topozone.com/
https://hackaday.com/2021/04/07/an-esp32-walkie-talkie-for-those-spy-radio-moments/