Edge Collective: E-Ink Map Display Prototyping

2020 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

figA2
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

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:

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:

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:

can sell for 4X to support project, or around $200?

If DIY kit:

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:

5-way tactile switch

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/

universal power cord adapter https://www.amazon.com/YIKU-Universal-5-5x2-1mm-Charging-Connector/dp/B0825SD9ZM/ref=asc_df_B0825SD9ZM/?tag=hyprod-20&linkCode=df0&hvadid=416794793908&hvpos=&hvnetw=g&hvrand=16523120492126351854&hvpone=&hvptwo=&hvqmt=&hvdev=c&hvdvcmdl=&hvlocint=&hvlocphy=9001876&hvtargid=pla-973096075837&psc=1&tag=&ref=&adgrpid=95587149484&hvpone=&hvptwo=&hvadid=416794793908&hvpos=&hvnetw=g&hvrand=16523120492126351854&hvqmt=&hvdev=c&hvdvcmdl=&hvlocint=&hvlocphy=9001876&hvtargid=pla-973096075837

-- 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 digikey https://www.digikey.com/en/products/detail/u-blox-america-inc/SAM-M8Q-0-10/7393573?utm_adgroup=RF%20Receivers&utm_source=google&utm_medium=cpc&utm_campaign=Shopping_Product_RF%2FIF%20and%20RFID&utm_term=&utm_content=RF%20Receivers&gclid=CjwKCAjw6fCCBhBNEiwAem5SO5nA43zsTMDsK6kBg4TkfYGYzt2dmapmRLDrsuMZJhlDdbG03UjLMhoCxygQAvD_BwE

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 friend: https://cdn-learn.adafruit.com/assets/assets/000/086/035/original/adafruit_products_Feather_eInk_Friend_sch.png?1576774972

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

tps783xx https://www.ti.com/lit/ds/symlink/tps783.pdf?ts=1616850726580&ref_url=https%253A%252F%252Fwww.google.com%252F

total supply on device needed:

so:

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!!

1000 uF capacitor https://www.digikey.com/en/products/detail/nichicon/UVZ1A102MPD1TD/4342138?utm_adgroup=Aluminum%20Electrolytic%20Capacitors&utm_source=google&utm_medium=cpc&utm_campaign=Shopping_Product_Capacitors_NEW&utm_term=&utm_content=Aluminum%20Electrolytic%20Capacitors&gclid=Cj0KCQjw0oCDBhCPARIsAII3C_EvNOyYeWGjdHGnfCCgVUi6RgGF35Gjn5o3K1FT3lty7302KYbdnSgaAj5EEALw_wcB

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

on digikey https://www.digikey.com/en/products/detail/adafruit-industries-llc/4800/13616787?s=N4IgjCBcoLQBxVAYygMwIYBsDOBTANCAPZQDa4ArAEwIC6AvvYVWSACxwAMnIDQA

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/