Power reduction for Raspberry Pi GPS/GSM tracker

Question

I've recently built a fully functional IoT GPS/GSM tracker with a Pi Zero for a college project and now that it's finished and done with, I would like to minimize the current draw of the entire system as two 2500mAh batteries can only power it for one to two days at most. However, I am still new to these devices and I would love some help regarding hardware changes and techniques.

My goal: A device capable of running python scripts that has a minimalist form factor (especially height) with lowest possible power draw.

My current setup uses:

---

• Raspberry Pi Zero
• Adafruit Fona 808 GPS & GSM
• Adafruit LSM303 Accelerometer & Magnetometer

I know about power-sipping Arduinos and MSP430's but I don't know if it is possible to do what I need it to do with these micro-controllers.

My questions are:

1. How steep of a learning curve is there to go from Raspberry Pi to more bare-bones boards?
2. Is it possible for these other boards to run GSM/GPS/Accelerometer concurrently?
3. Are there any other modules that provide the same functionality but consume less power? (I cannot find specific power numbers for these modules)
4. Will my current modules work with an MSP430 for example?
5. Any recommendations/comments?

Answer 1

I'll assume that the processing requirements on the device are near enough zero. It sounds like you're using some acceleration input to determine how often to wake up the GSM device.

Ideally, you want an MCU which can be triggered from the accelerometer to wake from sleep, and then determine when to send a location ping. Any micro-python based device should be a good starting point.

As an example of the power drain of a small board, the BBC microbit seems to use a couple of milliamps when the display is off (running at 16 MHz, and with the on-board accelerometer/magentometer powered).

Micropython supports 'sleep', but it will depend on the target platform how much power this saves you. Realistically, for this sort of application, a C++ embedded operating system will be no harder to code, and allows more flexability for saving a bit more power.

The first stage in calculating your power drain is to identify the different modes, and allocate an energy cost to each task. This allows you to compare the GPS/GSM message cost with the baseline daily idle power (doing no work). You can then see what the available saving is on each component. Provided your GSM module is only active for a few minutes a day, it's power consumption may be fairly insignificant.

Answer 2

In my experience the GSM and GPS modules draw far more power than the processor. This is to be expected as both of these contain lots of RF circuitry and the GSM module needs to transmit as well as receive.

The first step would be reconfigure your prototype so that you can monitor the power consumed by each part. Once you have that characterized, you would probably need to implement power control circuitry so that you only turn on the GPS and GSM modules when it is required. The longer you can afford to keep them off, the better the battery life you will get.

One of the problems with both GSM and GPS protocols is that if the unit is off for any considerable period of time, then it takes longer to re-establish connections and this will increase the time to first fix for the GPS and data circuit availability for the GSM.

Answer 3

Using MicroPython you possibly could switch from the consuming Pi Zero to some other platform. The official PyBoard is an STM32F405RG which could be good enough but there is support for the low-power STM32L4 series as well.

Currently you are running a Pi Zero at 1 GHz to use an UART and an I2C peripheral to interface your SIM808 and LSM303. The Pi consumes around 80 mA in idle, not speaking of when it is not.

If you could lower your CPU clock frequency you could lower your power consumption as well. For this task a couple of MHz would suffice.

So you could change to a PyBoard which consumes only a couple mA under 10 MHz in run mode with all peripherals ON.

Much less 0.4 mA in stop and 2.4 uA in standby mode.

Possibly you would have to port your scripts to MicroPython but that would be easier than porting them to C.