Introduction

Moteino began as a low power wireless Arduino compatible development platform based on the popular ATmega328p chip used in the Arduino-UNO. There are now several Moteino development boards including MoteinoMEGA based on the Atmega1284P and MoteinoM0 based on the SAMD21G18 Cortex M0+.

For programming you will need an external FTDI-Adapter to load sketches, the advantages being lower cost, smaller size. The MoteinoUSB and MoteinoMEGA-USB variant includes the USB-serial converter.

Moteinos are compatible and can communicated with any other Arduino or development platform that uses the popular HopeRF RFM69 or LoRa transceivers, or even the older RFM12B. Moteino also comes with an optional SPI flash memory chip for wireless programming, or data logging.

Video introduction to Moteino R3 and the RFM69 transceivers and library:

What about MoteinoUSB?

Moteino-USB includes the USB-serial FTDI chip. Technically a MoteinoUSB is the combination of an FTDI-Adapter and a regular Moteino. It can be programmed and powered via the USB connector but can also run from a battery (VIN pin) just as well:

What about MoteinoMEGA?

The MoteinoMEGA uses the Atmega1284p microcontroller. It still runs at 3.3V/16Mhz but has 128KB of internal flash (vs 32KB on Atmega328p), 16KB of RAM (vs 2KB), 4KB EEPROM (vs 1KB), 2x hardware serial ports, 8x PWM pins and bunch more GPIO pins. Still a small board at just 1.0×2.0″ and breadboard friendly. Comes with the same DualOptiboot bootloader making it “OTA” wireless programming capable, and can take up to 16V of input on the VIN pins (MCP1703 regulated).

To upload sketches to MoteinoMEGA you will need to first install the Moteino Core (instructions here). This defines the pin map and other important core definitions that allow the MEGA to be programmed from the Arduino IDE. Once that is done you should have a new board target under Tools>Boards called MoteinoMEGA


Moteino with trace antenna (868-915Mhz)

There are also two special Moteino variants with integrated PCB trace antennas, these are available for Moteino and MoteinoMEGA. The PCB antennas are tuned for the 868-915mhz bands and have an excellent performance given their compact size. Other than the PCB antenna, they are identical and work the same as regular Moteinos.

Why Moteino?

Moteino was designed to be a compact, highly customizable and affordable development platform, suitable for IoT, home automation and long range wireless projects. Here are some of the features that set Moteino apart:

  • small & light modular design fits in tiny enclosures
  • breadboard friendly and allows stackable shields
  • flexible configurations allow several wireless transceivers to be used
  • true ultra low power: with just ~2uA achievable in deep sleep mode, AVR Moteinos allow battery friendly projects like wireless motion/environment sensors to run for years. Watchdog sleep mode is at ~6uA (periodic wake). The new 8Mhz Moteino allows the lowest possible 100nA sleep mode. The new SAMD21 Cortex M0+ based MoteinoM0 sleeps at just ~8uA!
  • sub-Ghz and LoRa radios yield much longer range than 2.4Ghz bands
  • wirelessly (aka OTA) programmable: be able to re-flash it without wires, when deployed in difficult locations (supported with RFM69 radios only)
  • easy to use from the familiar Arduino IDE, many code examples given to help get started
  • affordable: zero-cost wire monopole antennas yield excellent RF range for all-around wireless projects. With the u.FL/IPEX and SMA connector pads you can attach any other external antennas with higher gain
  • visit the user projects forum to see how people are using Moteinos
  • See LowPowerLab’s home automation platform: Moteino IoT Gateway project

Why the funky name “Moteino”?

Mote + ino, obviously.

Moteino aka…

Since “Moteino” is so hard to pronounce, write and remember, here is a list of (funny) names that people have dubbed it over the years:

Moreduino
Moetino
Moiteno
Moduino
Modeino
Montenio
Moneinto
Monetino
Monteino
Moreno
Moteduino
Noteino
Motenio
Moteiono
Motuino
Motenino
motetino
Moteuino
Motino
Motion
Moteion

And no, we didn’t make this list up!

Out of box

Moteinos come without any soldered headers or antennas. Without the wire antenna the range will be only a few feet, and while this is OK for testing purposes it’s recommended that an antenna be soldered before real application use of the transmitter. The provided wire monopole antenna has to be soldered to the “ANT” pin hole (just above the FLASH chip) to achieve any usable range. Regular Moteinos will come with a 1×6 male header that you have to solder before you can power it and upload sketches through an FTDI Adapter. Moteino-USB has built in USB so you only need a mini-USB cable for programming.

Video demonstration of soldering headers and wire antenna:

Pinout diagrams (click to enlarge):

Specifications

Moteino

MicrocontrollerATmega328p
TransceiverRFM69,  RFM95/RFM96 LoRa,  RFM12b
Frequency bands433Mhz, 868Mhz (EU), 915Mhz (US, Australia, etc.)
Input Voltage (VIN pin)3.6V-16V (up to 12V recommended)
Core operating voltage3.3V (regulated via MCP1703 low dropout regulator)
Digital I/O Pins14+6 (6 PWM capable: marked with “~“)
Analog Pins8 (2x analog-only pins more than regular Arduinos)
DC Current per pin10 mA
Program Memory32 KB of which 1 KB used by DualOptiboot bootloader *
SRAM2 KB
EEPROM1 KB
Clock Speed16 MHz via external ceramic resonator
Power usage~8mA (no sleep, LED blinky sketch)
Lowest power6.5uA with stock regulator & fuses (sample sketch)
MISCOnboard LED on pin D9 (PWM capable!)
Radio transceiver SPI-CS on D10
FLASH SPI-CS on D8
A6 and A7 are analog pins only, cannot be used as digital pins

* DualOptiboot is a modified version of the standard Optiboot bootloader (size is 1k instead of 512bytes). For plain FTDI/serial programming you can still use the Arduino Uno target for uploading to a Moteino, as long as your sketch won’t exceed 31KB. To avoid issues and support MoteinoMEGA, you should install the Moteino Core which contains the definitions for all Moteino boards.

MoteinoMEGA

MicrocontrollerATmega1284p
TransceiverRFM69,  RFM95/RFM96 LoRa
Frequency bands433Mhz, 868Mhz (EU), 915Mhz (US, Australia, etc.)
Input Voltage (VIN pin)3.6V-16V (up to 12V recommended)
Core voltage3.3V (regulated via MCP1703 low dropout regulator)
Digital I/O Pins24+8 (8 PWM capable: marked with “”)
Analog Pins8
DC Current per pin10 mA
Program Memory128 KB of which 1 KB used by DualOptiboot bootloader *
SRAM16 KB
EEPROM4 KB
Clock Speed16 MHz via external ceramic resonator
Power usage~8mA (no sleep, LED blinky sketch)
Lowest power6.5uA with stock regulator & fuses (sample sketch)
MISCOnboard LED on pin D15 (PWM capable!)
Radio transceiver SPI-CS on D4
FLASH SPI-CS on D23

Moteino 8Mhz variant

There is now a Moteino 8Mhz variant. This has no LDO and hence allows to harvest the lowest power modes from the Atmega328p MCU. It has the following differences to the regular Moteino:

  • no LDO linear regulator
  • the VIN and 3v3 pins are connected by a 0ohm resistor (bridge)
  • must be powered from 3.6v or less when RFM radio and/or FLASH-MEM are installed. The RFM radio and FLASH-MEM are damaged by 5V. Without these components the board will work up to 5V.
  • 16mhz resonator is still installed but not used with the 8Mhz fuses. This means you can change the fuses yourself and run the board at 16Mhz it if you’d like, but this will only be safe down to about 3.3V
  • fuses are: LOW: 0xD2, HI: 0xDC, EXTENDED: 0xFE
  • even more ultra low power – 2uA less current than the regular Moteino
  • runs DualOptiboot compiled for 8mhz
  • 57600baud upload programming speed (vs. 115200)
  • you will need to install the latest Moteino definition (v1.3 or newer) in your Arduino IDE Board Manager to gain the new Moteino (8Mhz) target board:

These types of Moteinos are ideal for ultra low power coin cell and other micro power powered nodes – power them from 3.6V or less. Of course, when you have such tiny power supplies, you must choose your transceiver carefully, as you likely cannot transmit at full 20dBm power from a tiny coincell. The W/CW 13dBm radios running the auto-power-dial RFM69_ATC library extension would be recommended for running on coin cells or small solar cells.

To program this Moteino the FTDI-Adapter offered in the shop can be modified to pass a safe 3.3V to the 8Mhz LDO-less Moteino – cut the *5V Output Voltage jumper and solder the 3.3V one:

Note that this mod will make the FTDI-Adapter regulate power, but it can only supply about 50mA to the Moteino, if you draw more power, the adapter might drop and reconnect to your computer

Alternatively, you can build a dedicated adapter that takes the 5V from the USB and regulates it to 3.3v, here’s such an example which uses the LDO from the Moteino itself (MCP1703) along with a 1uF and 0.1uF caps, all other connections are passed through and assumed to be 3.3v levels:

You would then use it in between your stock unmodified FTDI-Adapter (or equivalent board, providing 5V VIN power and 3.3V TX/RX/DTR signals), and the no-LDO Moteino which requires 3.3V when radio/flash are present:

Moteino M0

The MoteinoM0 (release notes) is a SAMD21 Cortex M0+ based Moteino featuring these general specifications:

  • ATSAMD21G18A microcontroller (48pin LQFP) running at 48Mhz, 3.3V core
  • Input voltage: 3.6-6V
  • Digital pins: 23 (11 PWM)
  • Analog ADC pins: 6 (12bit)
  • Analog DAC pins: 1 (10bit)
  • Flash Program memory: 256KB (8KB used by bootloader)
  • SRAM: 32KB
  • Transceivers: RFM69HCW, RFM95, RFM96
  • Low power: ~8uA in standby mode (FLASH and transceiver in deep sleep)

Memory & Bootloader

The MoteinoM0 runs the standard Arduino bootloader (compatible with Arduino/Genuino Zero). The bootloader is enhanced to allow flashing the memory from the external FLASH-MEM memory. This is compatible with Dualoptiboot and OTA/Wireless programming. The booloader is located in the first 8KB of internal flash memory and is protected by the NVM user byte fuse.

There is no dedicated EEPROM on the SAMD21 microcontroller but EEPROM can be emulated up to 16kb and the Arduino EEPROM library can be used to access this emulated EEPROM.

Pin reference

Schematic

Hardware / Driver install

To use MoteinoM0 with ArduinoIDE you will need to install the latest Arduino SAMD Boards package and then also the Moteino SAMD Boards package by LowPowerLab:

If you’re on MAC or Linux you should not need any drivers. Also Windows 10 will probably detect the board as a virtual serial port and assign it a COM port by default without the need of installing a driver. Older Windows versions are likely going to fail to install a driver when MoteinoM0 is first plugged in. Click below to get the USB driver and unzip it to your Desktop or another folder. The ZIP file contains a screenshot walkthrough of how to install the driver.

Using with the ArduinoIDE

It’s important to understand how the board operates and how to enter the bootloader to ensure you can program it regardless what state the board is in. The bootloader behaves identically to the Arduino Zero samba bootloader, so if you’re familiar with that board, you should be all set.

If you load a low power sketch, or turn off the USB-Device (serial port) in your sketch, or even using certain sketches will cause the board to appear unresponsive to an Upload command while it’s in sleep mode or if it’s caught up doing other things. In such cases an Upload will fail from the IDE, and it’s necessary to do a fast double-tap on the RST button to put the board in bootloader mode. In some even more precarious situations where the board does to sleep immediately after boot, you might need to first do a single tap, then shortly after do the double-tap. You know you have entered the bootloader when the onboard LED is in a breathing pattern and a new serial port appears. Once there, select the new serial port, and try an Upload. There will be a delay until the board receives the sketch, or if you’re in a hurry you can jump start the upload by doing another double-tap. It’s only confusing until you manage to do this a few times!

Example sleep sketch

The sketch below illustrates how to put the MoteinoM0 to standby sleep (lowest power sleep), and optionally wake it from an external interrupt (active low on digital pin 0). It also puts the FLASH-MEM and transceiver (if any) to sleep.

//Standby sleep example for MoteinoM0 with external interrupt wakeup
//expected current in standby sleep: 7.5uA
const int pin = 0; //pin to use as interrupt (can be any digital pin)

//#define WITHRFM69  //comment this out if you don't have a radio installed on your MoteinoM0

#ifdef WITHRFM69
  #include     //get it here: https://www.github.com/lowpowerlab/rfm69
  #define NODEID        2   //must be unique for each node on same network (range up to 254, 255 is used for broadcast)
  #define NETWORKID     100  //the same on all nodes that talk to each other (range up to 255)
  #define GATEWAYID     1
  #define FREQUENCY     RF69_915MHZ
  #define IS_RFM69HW    //uncomment only for RFM69HW! Leave out if you have RFM69W!
  RFM69 radio;
#endif

#include        //get it here: https://www.github.com/lowpowerlab/spiflash
SPIFlash flash(SS_FLASHMEM, 0xEF30); //EF30 for 4mbit  Windbond chip (W25X40CL)

//replace Serial with SerialUSB
#if defined (MOTEINO_M0)
  #if defined(SERIAL_PORT_USBVIRTUAL)
    #define Serial SERIAL_PORT_USBVIRTUAL // Required for Serial on Zero based boards
  #endif
#endif

void setup()
{
  Serial.begin(115200);
  delay(500);
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(0, INPUT_PULLUP); //using internal pullup, makes pin 0 active low

  //Uses internal pullup eliminates the need for external resistor and makes interupt pin active low
  //If you need active high, then attach to HIGH and declare pin as INPUT without PULLUP, then use external resistor from GND to pin to keep it from floating
  attachInterrupt(pin, wakeupISR, LOW); //note: RISING and FALLING do not seem to work, use LOW or HIGH instead

  if (flash.initialize())
  {
    Serial.println("flash.init() OK, sleeping it...");
    flash.sleep();
  }
  else Serial.println("flash.init() FAIL");

#ifdef WITHRFM69
  if (!radio.initialize(FREQUENCY,NODEID,NETWORKID))
    Serial.println("radio.init() FAIL");
  else
    Serial.println("radio.init() SUCCESS");
  
  #ifdef IS_RFM69HW
    radio.setHighPower(); //uncomment only for RFM69HW!
  #endif
    radio.sleep();
#endif

  for (byte count=0; count < 3; count++)
  {
    Serial.print(".");
    blink(500);
  }
  Serial.println("Entering standby sleep mode...");
  delay(100);
}

void loop() 
{
  standbySleep();

  //interrupt happened: WAKE UP and blink the LED!
  blink(50);
}

void blink(int ms) {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(ms);
  digitalWrite(LED_BUILTIN, LOW);
  delay(ms);
}

byte toggle=true;
void wakeupISR(void)
{
  //nothing here, just a placeholder
}

void standbySleep() {
  //Disable USB (optional)
  //USBDevice.detach();

  //Standby - lowest power sleep mode
  SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk;
  __DSB();
  __WFI(); // Wait For Interrupt call

  //Sleep until woken by interrupt...

  //Enable USB
  //USBDevice.attach();
}

Transceivers

Here is a quick side by side comparison of different HopeRF radio transceivers. There are different aspects of compatibility between them which we discuss below.

For the transceivers to work properly with the RFM69 library, you must always check the radio settings in your sketch. Particularly the RFM69HW and RFM69HCW radios require invoking radio.setHighPower() after radio.init() (usually controlled by the #define IS_RFM69HW_HCW directive), see how this pattern is implemented in the library examples. For RFM69W & RFM69CW you should *not* call radio.setHighPower() – ie comment out the #define IS_RFM69HW_HCW line. Doing this incorrectly will result in no wireless range and can even damage your transceiver!

All Moteinos now accept these types of transceivers:

What is the difference between W/CW/HW?

The W/CW/HW are different configurations of the same Semtech SX1231h transceiver chip (custom packaging by HopeRF). They come in different transmission power and frequency variants. For instance the W and CW are 13dBm power output. The HW and HCW are 20dBm power output.

All RFM69 radios can communicate with each other regardless of their configuration/layout (as long as the above settings are correctly set) when their network ID and encryption (optional) keys match. Their node IDs should be unique, the RFM69 library supports up to 255 nodes per network. The broadcast address is 255, sending a message to that node ID=255 will make all listening nodes receive that message.

Pin compatibility

The W and HW are pin compatible. The HCW are only pin compatible with the RFM95/96 LoRa radios. The CW radios are pin compatible with the older RFM12B.

Code/settings compatibility

The W and CW are equivalent in coding and settings usage, and same is true for the HW and HCW. In fact, the only setting difference between W/CW and HW/HCW is the very important #define IS_RFM69HW_HCW directive discussed above.

Frequency markings

Since it’s not easy to distinguish between the same radio of different frequencies (except marked on the bottom by HopeRF), LowPowerLab has its own marking convention for the transceivers to quickly identify frequency once they are soldered to Moteinos. The 433mhz radios are marked with a gold dot. The 868/915mhz are marked with a silver dot. Other vendors also mark their HopeRF radios but have different colors.

RFM69 and RFM95/96 LoRa compatibility

RFM95 and RFM96 are *not* compatible with RFM69 and require a 3rd party library, see the LoRa page for details. However RFM6 (HCW only) and RFM95/96 LoRa radios are pin compatible, enabling them to share the same mounting pads.

Chip marking confusion between RFM95 and RFM96

RFM95 and RFM96 can be confused because they both have a chip marked with “RF96“. They are in fact different, as can be noticed in the photo above. Although the chip is the same, the components are mounted differently, reflecting their different frequency operation. The markings on the back of the module also makes this distinction.

What about RFM12B?

RFM12B can be used on Moteino/MoteinoUSB/MoteinoMEGA but this radio is not supported for new development and older code/library is only kept for reference.

LoRa support

Since 2015 Moteino also supports LoRa transceivers:

The LoRa technology from Semtech brings exceptional features like high reception sensitivity and spread spectrum modulation allowing these radios to dramatically increase range at low bitrates, while still operating at a battery friendly output power (20dBm/100mW) and ultra low power sleep mode. These radios also support FSK modulations but they are intended to be used with the LoRa (Long Range) modulation technology and as such they will only be supported by LowPowerLab in that operation mode. This also implies they cannot communicate with any RFM69 radios (except via a bridge module between two such networks is built). In other words, they are a completely different type of radio for a different category of communications.

While Moteinos are pin compatible with all LoRa radios (RFM92-RFM98), the LowPowerLab Shop carries the RFM95 (868-915mhz) and RFM96 (434mhz).

Long range possibilities of LoRa

For an in-depth technical review of this technology please see this great instructable. Here’s how the LoRa modulation looks like:Here’s a test performed at 1000bps (see instructable for more details):

Library & usage of LoRa modules with MoteinoMEGA & MoteinoM0

The recommended library to use with RFM95/95 LoRa modules can be downloaded here (this should be installed like any other library under your Arduino/libraries folder). This the popular RadioHead library by Mike McCauley. The examples to get started with are under examples/rf95: rf95_server and rf95_client. Choose your Moteino target under Arduino>Tools>Board and upload the examples to your Moteino. Note that the LED is on D15 (MoteinoMEGA) and D9 (all other Moteinos). If you have an RFM95 then set frequency to 915Mhz, for RFM96 use 434Mhz. For details and documentation visit the official RadioHead library page.

For MoteinoMEGA, the SPI slave select pin is digital pin 4, and radio interrupt pin is digital pin 2. If you use the original RadioHead library you must call the constructor like this with MoteinoMEGA (complete reference here):

RH_RF95(4); //SPI CS init with MoteinoMEGA

For MoteinoM0 you must call the constructor like this:

RH_RF95(A2, 9); //SPI CS init with MoteinoM0

You may also download a patched version of RadioHead v1.8.4 which ensures the default constructor works with MoteinoMEGA and MoteinoM0.

If you use IDE 1.0.6 or older and having trouble compiling the latest RadioHead, you may try this older archived version of RadioHead.

Programming & libraries

You will need to install the Moteino package in your Arduino IDE – this includes definitions for all Moteino boards and MightyHat. First add the Moteino core json definition URL to your Board Manager.

Then in Board Manager you will see AVR and SAMD boards by LowPowerLab.

For AVR based Moteinos and MightyHat you need to install the Moteino AVR Boards package. For MoteinoM0 you need to install the Moteino SAMD Boards. Once installed the new boards will show in your Tools>Boards menu:

There is now a programming guide for Moteinos which helps you get started with libraries and programming in Arduino IDE, please check it out if you are new to Arduino. Quick steps to programming in the Arduino IDE:

  • First, you need to download and install the necessary libraries in your Arduino/libraries folder: RFM69 library, SPIFlash library, you can use the Arduino Library Manager (unde Tools > Manage Libraries menu) to install the latest version of these libraries:
  • For RFM95/96 LoRa radios please see the LoRa section of this guide
  • Get started with RFM69 example sketches: Sender and Receiver
  • To upload a sketch, select Arduino Uno in the Tools>Boards menu in the Arduino IDE, and the serial port emulated by your FTDI-Adapter or USB-serial adapter in Tools>Serial Port
An FTDI-Adapter that can be used to program Moteinos (non USB variants). If you have a MoteinoUSB or MoteinoMEGA-USB a separate FTDI-Adapter is not necessary

The VIN pin of AVR Moteinos is shared with the VIN pin on the FTDI header. If you power your Moteino externally from the VIN pin, make sure to disconnect the external source when you attach the FTDI-Adapter!

The FTDI header has silkscreen markings for the GND and DTR pins to help you align your FTDI Adapter (black and green wires respectively on the FTDI cable). Usually the PCB based FTDI adapters also have the same markings on their end (see the FTDI Adapter).

The Moteino can be used like Arduino, but for wireless communications you will need a library for the RFM69 transceiver. You can use the official RFM69 library for RFM69 Moteinos, it has a suite of examples to get you started.  The simplest way is to start with the Node and Gateway examples. For RFM95/96 LoRa transceivers please see this section for more details. See this official tutorial on installing Arduino libraries if you’re not sure how to install an Arduino library.

Wireless programming

All Moteinos come with the DualOptiboot bootloader which enables them to be wirelessly programmed when the FLASH MEM chip is installed (also available separately).

The wireless programming protocol is generic and supported by all Moteinos with DualOptiboot and FLASH Memory option, but the example implementation was only done for RFM69 transceivers

You will need to program a Moteino with a sketch that listens to such wireless programming commands first before it can be programmed over the air. There’s a proof of concept and source code described in this blog post.

A Windows desktop GUI app is available to make wireless programming easy. This program is available here at Gihub. The sample programmer and target sketches that support the wireless programming are in the RFM69 library. Here’s the GUI interface:Here’s a rundown of the features:

  • gives you a list of available serial ports so you don’t have to guess (you still have to know which serial port your wireless programmer Moteino is connected to)
  • allows you to type/paste or browse for a hex file
  • allows a numeric target node ID
  • once all controls are populated with valid info, the Start! button is enabled
  • upon exit, it saves the settings to registry and attempts to read them back in future launches

Using python instead of desktop app

You can now use the OTA.py python script cross platform which does the same thing as the Windows application except it needs to be passed command line arguments (com port, baud, hex file etc) – type python OTA.py -help for details. The OTA.py script is now bundled and can be invoked in the Windows application.

Antenna options

If you are new to RF and Antennas, consider reading this RF Best Practices guide for a basic understanding of wireless and radio technology

Moteinos are shipped with 1/4 wavelength monopole wire that should be soldered to the ANT pin. Each frequency has a specific antenna wire length. Without the antenna Moteinos will only have a few feet range at most. See this forum post about some antenna theory. You can increase the RF performance with dipoles (1/2 wavelength). See this forum thread for some open source dipole antennas. The default basic monopole wire has an excellent performance to cost ratio.

You can also solder SMA or U.FL connectors and hook up other types of antennas:

On older Moteinos you can carefully solder u.FL or SMA connectors between the ANT pin and GND:

Range is a difficult to estimate because RF performance is affected by very many factors. Any obstacles between nodes can absorb or deflect the signal. Atmospheric conditions can also have an impact (humidity, rain, snow etc). Some basic tests with RFM12B and RFM69W in open air with the basic sample sketches reveal these range results:

RFM69HW is a higher power version of RFM69 (20dBm vs 13dBm) and it can reach significantly futher. Other users have done some experiments and have reported various ranges:

Here is an example range test of 2.5Km with stock Moteinos and some interesting BiQuad antennas, build details in the forum:

  

FLASH-MEM option

The FLASH-MEM option was introduced in Moteino R2 to allow SPI flash memory (SOIC JEDEC 3.9/5.3mm body width package) to be added to Moteinos primarily for wireless programming (but can be used as non-volatile storage for any purpose). There is an SPIFlash library just for using this memory chip. The SPI CS select for this is connected to D8 on all Moteinos (D23 on MoteinoMEGAs).

The chip shipped on all Moteinos is the Windbond 4mbit W25X40CLSNIG. Higher capacities are available upon request for custom batches.

The DualOptiboot bootloader allows you to reflash the program from a flash image stored on the external FLASH MEM chip (wirelessly programming it). See this blog post for how wireless programming is achieved using DualOptiboot and more details. This is the pinout of the FLASH MEM chip used on all Moteinos:

FLASH_pinout

Why flash chips and not SD cards that come in much larger sizes at low cost? Because of the size and power constraints, an SD card slot would increase the cost. A separate SD-card Moteino shield would be more appropriate for an SD card add-on.

Revision history

  • Moteino R4 – same as R3 except it can take RFM69W/HW transceivers. It replaces R3 and R2. Includes the FLASH-MEM option, comes with DualOptiboot, and has a full GND pour on both sides. Also ENIG lead-free finish. Needs an FTDI Adapter for programming.
  • Moteino R5-USB – same as regular Moteino but has built in USB serial bridge which allows direct programming through a mini-USB cable without a separate FTDI Adapter.
  • MoteinoMEGA – Moteino based on atmega1284p with 128KB of internal flash and 16KB of RAM for the most memory demanding sketches. A bunch more IO and an extra hardware serial port make it the ideal choice for for more complex projects.
  • MoteinoLR and MoteinoMEGA-LoRa – Same as other Moteinos, except they work with RFM95/96 LoRa and RFM69HCW radios, see the LoRa page for more details.
  • R3 – same as R2 except with support for the new RFM69W/HW transceivers. Includes the FLASH memory footprint and loaded with a modified Optiboot bootloader (DualOptiboot) to allow wireless programming.
    Moteino_R3_banner 
  • Moteino R2 – Green mass produced PCBs. Includes the FLASH memory footprint. Loaded with a modified Optiboot bootloader (DualOptiboot).
    Moteino_R2Moteino_r2_bunch
  • Moteino R1 – The first Moteino revision. These were produced at OSHPark (purple), did not include a FLASH footprint, and had slightly different bootloader and fuse settings. Some early orders received this version.
    Moteino_front_back2Moteino_assembledMoteino_with_RFM12B
  • MoteinoLeo (discontinued) – Arduino Leonardo variant based on the ATMega32u4 chip and Caterina bootloader. It has been discontinued, but you can find some of the the design files on Github. For the initial prototype details click here.
    MoteinoLeo_R1_withFlashMoteinoLeo_bottom_compared_small

Design files

Schematics

You can also find Eagle format board layout and DXF in the Moteino Github repository. The schematics for MoteinoUSB is available in PDF format.

Dimensional drawings

CAD model

There is now a CAD model for the Moteino-TraceAnt here:

Fritzing components

Thanks to the generous contribution of Donnie Plumly there are now Fritzing Parts available for Moteino. Check out this Github repository for the details. Here’s a video he put together that shows how he actually built the Moteino part in Fritzing:

Side note: although Fritzing is not the best PCB layout software, some folks find it visually appealing to start laying out a circuit in Fritzing and perhaps build a PCB from that if the schematic and routing requirements are pretty basic. It’s great for illustrations and getting started with basic schematic and circuit layout.

 

MISC

YouTube review of Moteino R2, by Alan (w2aev)

Video introduction to Moteino Rev1:

How Moteinos are made

In the present all Moteinos are machine assembled on a pick and place and reflowed in a real 3-zone conveyorized reflow oven. Watch this video lapse of a MoteinoMEGA panel assembly:

In the beginning…

… they were hand assembled using various tools that I built to make the job easier and faster. For instance I was using a home-made SMD metal stencil to spread solder paste to the bare PCBs. I then place the SMD components using a manual home-made PnP (pick and place) “apparatus”. I reflowed the boards in a toaster oven following a reflow profile, and hand solder the transceivers on the bottom. I then set the fuses and load the bootloader using a programming jig.

apply pastebakeprogramming jig

Here’s a video of some hand assembly action: