Some especially useful links:

Loading your first Arduino Sketch on your M2:

Adapter board that replaces M2 processor board with PocketBeagle:

M2 has several low-power options. One of them is called, J1850 / ISO 9141 Low Power Control.

We have 2 microcontroller-controlled switches that allow "+12V_SW" and "+5V_SW" to be powered on or off depending on conditions.

The signal J1850_9141_ON controls this and is connected to the SAM3X pin number 120 (PB5)

The following code turns on or off the 12V and 5V rails:

Using your M2

There are many ways you can write code and work with M2. One of the quickest and easiest ways is to use the Arduino IDE (Integrated Development Environment) which is what this documentation will use. Many other development environments work well including Atmel Studio and Simulink®.

The first thing you will need to do is set up the Arduino IDE. After that you might choose to build and run an existing project or write something your own. There are many libraries available for the M2 and most include example sketches that you can run on your M2.

Enclosures

It is ok to do some initial setup before you have an enclosure, but before your M2 spends long periods in the car please consider protecting it. We have a few configurations of enclosures designed and ready for 3D printing. You can download the designs, tweak them as needed, print, share, lather, rinse, repeat.

Find more about enclosures here.

M2_SD_HSCMI

Gives access to HSMCI (High Speed MultiMedia Card Interface) on M2.

OBD9141

A class to read an ISO 9141-2 port found in OBD-II ports.

due_wire

An alternative I2C library for Due with DMA support

For an image showing the pin names of the XBee socket on M2, click here.

USB

M2 has a USB connector that can act as either a HOST or DEVICE depending on your code.

M2 uses Native USB port only. To print something to the Serial monitor, you'd need to use this command:

microSD

The M2 contains a microSD socket. Unlike most Arduino implementations of SD, we chose to employ the HSMCI (High Speed MultiMedia Card Interface) as the connection method. The result being both faster reading and writing, and freeing up the SPI interface for other fun stuff. If for some reason, SPI is needed, we did include some 0 ohm jumpers on the PCB to allow for SPI connection. These are left open by default.

For in-depth explanation of how the HSMCI works, refer to the SAM3X datasheet, starting on page 909.

Using the SD card slot on your M2 is pretty straight-forward since the complexities are abstracted through a library which was automatically installed for you when you setup your Arduino IDE for the Macchina M2. A description of the examples included with the library can be found here.

Back in the main window, the frames sent by fuzzing should be listed.

View CAN Traffic in a Vehicle!

After this step you're ready to move your A0 to a vehicle and connect to it using the same steps as above (you may want to enable Listen Only to avoid any accidents at first).

• 5) Hit RESET on the USB adapter board, the SuperB should report back ready.

Try the following two commands sequentially to get a list of access points visible to the SuperB:

For a full list of available AT commands click here.

A0 Sketch

Upload👉THIS SKETCH to your A0, which queries the vehicle for speed, engine RPM, and coolant temperature, and prints the results to the serial monitor. It requires two libraries, which can be found👉here and👉here.

Vehicle Setup

Plug A0 into the OBD-II port found beneath the dashboard (usually between the steering wheel and pedals, by your left knee). Keep A0 connected to your computer with the USB cable and open the Arduino IDE's serial monitor at baud 115200.

Test

Try revving your engine and watch as the RPM updates in the serial monitor. You can also try driving and watching the vehicle speed and engine coolant temperature.

Example Data

Upload 👉 THIS SKETCH to your A0, which queries the vehicle‘s Vehicle Identification Number (VIN), and prints the result to the serial monitor. It requires two libraries, which can be found 👉here and 👉here.

Vehicle Setup

Plug A0 into the OBD-II port found beneath the dashboard (usually between the steering wheel and pedals, by your left knee). Keep A0 connected to your computer with the USB cable and open the Arduino IDE's serial monitor at baud 115200.

Test

Watch the serial monitor. It should print out the VIN of your vehicle.

How It works

The Vehicle Identification Number (VIN) can be read from a vehicle using standard OBD-II commands. Several messages must be exchanged because the VIN is too long to fit in a single 8-byte CAN frame.

Standard OBD services are defined in ISO 15031-5. Service 09 - Request vehicle information allows requesting the VIN. The network protocol used to split this request over multiple CAN frames is defined in ISO 15765-2.

The sequence of messages used to read a VIN is as follows:

0x7DF | 02 09 02

A0 sends message from functional request ID 0x7DF. It is a SingleFrame with length of 2 (02). It is a request for the Request vehicle information service (09). The InfoType is VIN (02).

0x7E8 | 10 14 49 02 01 31 4D 38

Response from ECU #1. It is a FirstFrame with length of 20 (10 14). It contains the first 3 characters of the VIN “1M8” (31 4D 38).

0x7E0 | 30 00 00

A0 sends message using ECU #1 request address. It is a FlowControl frame with status ContinueToSend (30). The BlockSize value tells the ECU to send all remaining frames (00). The SeparationTime is 0ms (00).

0x7E8 | 21 47 44 4D 39 41 58 4B

0x7E8 | 22 50 30 34 32 37 38 38

The ECU responds with two ConsecutiveFrame messages with sequence numbers 1 (21) and 2 (22). Each contains seven more characters of the VIN.

The VIN can then be assembled by combining the characters from each of three frames sent by the ECU: 31 4D 38 47 44 4D 39 41 58 4B 50 30 34 32 37 38 38, which translates to 1M8GDM9AXKP042788 in ASCII.

Goals

As we developed the Macchina M2, we set out with the following goals:

• Help foster a new generation of car nerds

• Develop an innovative product for a wide range of automotive functions

• Support the DIY and Open Source ecosystem

• Provide companies with a great tool for fast prototyping

• Display our ability to develop and mass produce quality hardware

Specification

We designed the M2 to be modular and the result was three main related, but independent, components.

The M2 is an open source automotive interface that takes the form of an OBD2 "under-the-Dash" dongle or hard-wired "under-the-hood" device. Each M2 has all the interface circuitry needed to connect to the 5+ standard OBD2 protocols plus other interfaces such as a second CAN bus, LIN bus, and single-wire CAN. It also includes several options for connections to the outside world including: SD card, USB Device and Host, 20-pin (sort of standard) XBee socket, and a general purpose connector.

The Interface Board provides most of the hardware support for automotive connections. The goal was for M2 to be able to interface and communicate with as many cars as possible. We crammed 2 channels of CAN, 2 channels of LIN/K-LINE, a J1850 VPW/PWM and even a single-wire CAN (GMLAN) interface onto the board. Automotive environments require the M2 to be seriously strong, so we built in plenty of protection circuitry. Lastly, we have 6 general purpose driver circuits, which can source and sink up to 1 amp of current at 12 volts!

The Processor Board is the standard computing engine for the Macchina M2. We chose the Arduino Due as the basis of M2's processor board. Shrinking the Due by well over 50% was no small task! We decided to make further improvements by using the High Speed SD card interface and writing the appropriate firmware libraries to allow for faster data logging. We also added several LED options and a couple switches for a more pleasant development experience. Lastly, we tacked on an EEPROM to store variables after power is cut to M2. The processor BCB can be swapped with a Breakout Board to more easily use the M2 Interface Board with your choice of processor.

A wireless socket on the M2 Processor Board accommodates a wide variety of wireless options using the popular DIGI XBee form factor socket. Many inexpensive, plug-and-play boards already exist including BLE, WIFI, GSM, 3G, LTE, GPS and others. This can even be used to reprogram the M2 wirelessly.

History of M2

The Macchina M2 was in development for years prior to its release and the team behind it has been working together on other projects for much longer. Building the M2 has always been a goal of ours. Our crowdfunding campaign was the catalyst that transformed us from friends and an idea to a company and a product. We are very thankful to everyone who enabled this transformation. We repay you through our hard work and dedication to this project.

We would also like to thank the organizations that have helped build the communities that the M2 relies on: Arduino, DIGI International, Digi-Key, the EFF, Hackaday, and Open Garages. Finally, to the developers who spend their own time building essential tools, answering questions on the forum, and testing, thank you.

Using your phone's Bluetooth settings, connect to ELM327-A0.

Configure Torque

Enter the settings in Torque, and then the "OBD2 Adapter Settings". Ensure connection type is set to Bluetooth and then select ELM327-A0 under the "Choose Bluetooth Device" option.

Done!

After this point consult the Torque Wiki to learn how to use Torque.

Use A0 with SavvyCAN

A0RET allows A0 to work with SavvyCAN via Wi-Fi, no wires needed!

Download SavvyCAN

Follow the link below to download the latest release of SavvyCAN as a zip archive. Then unzip to a folder.

Run SavvyCAN

First run vc_redist.x64.exe to install the Microsoft Visual C++ Redistributable, then run SavvyCAN.exe to open SavvyCAN.

Add a Connection

Go to Connection->Open Connection Window to begin adding a new device.

At this point, plug A0 into the car. Then, from the computer running SavvyCAN, connect to its Wi-Fi network. The defaults are:

SSID: A0RETSSID

Password: aBigSecret

Click "Add New Device Connection" and select "Network Connection"; the IP address should pre-populate since we have already connected to A0's network.

You should now start seeing CAN traffic in the main window of SavvyCAN.

The A0-specific steps have now all been completed and you have free reign in the huge playground that is SavvyCAN, visit their extensive documentation below:

For a more detailed look at A0's built in capabilities, go to:

• Open source hardware

• XBee form-factor compatible (3.3 V levels, UART, SPI and GPIOs broken out to headers)

• Based on popular ESP32 SoC

• Wi-Fi (802.11 b/g/n)

• Bluetooth (Classic and BLE)

• Programmable with many tools, including Arduino IDE

• OTA (Over-the-Air) flashing capable

• Dual Core processor up to 240 MHz

• Integrated 4 MB flash - we may upgrade this to 16 MB

• Sleep current is less than 5 μA

• Fully certified with integrated antenna and software stacks

• One programmable LED

What can SuperB do for you?

We designed SuperB as a wireless solution that plugs into the Bee socket of M2, our automotive interface hardware. Fortunately for you and us, Bee sockets are found everywhere, with over ten million Bee modules deployed to date. Wherever the modular Bee socket is found, SuperB will work. Some examples? SparkFun’s Wireless Joystick Kit and Adafruit’s Tweet-a-watt are two great examples of cool Bee-ready hardware and projects available today.

SuperB will come preloaded with AT Command code, allowing you to communicate with ESP32 over UART with any microcontroller using standard AT commands. Want to use it like an Arduino? Program SuperB using the Arduino IDE for whatever you are looking to build. You can even program SuperB to act as a wireless bootloader for a host system. Better yet, you can reprogram SuperB to wirelessly connect SavvyCan, creating a wireless car hacking dynamic duo with M2! Check back for instructions and code in a future update!

External Antenna Availability

Built-in 'trace' antenna: This is the original SuperB design. It uses the ESP32-WROOM-32D module, and the antenna is built into the device.

U.FL for external antenna: This option uses the ESP32-WROOM-32U module, and allows you to connect your external antenna via U.FL connector. This option works well when you plan to enclose your SuperB in a metal box, tin foil hat or other material that interferes with antenna reception. Please note that users need to provide their own antenna solution for this option.

This is related to many problems we have seen - examples include A0 or M2 not reflashing correctly. We test every unit that ships to try to prevent this. While the ultimate solution varies from case to case the most common issue by far is a bad USB cable. It is not good enough to verify the cable works with another product as USB implementation and cable configuration vary. Please test with multiple cables. The one we verify with is available in our store. Drivers and worn out ports also frequently come up.

Arduino IDE Board Manager Issues

Description: After entering a new board manager URL in File->Preferences, going to Tools->Boards Manager causes a Java error. Upon closing, Arduino IDE will be unable to reopen until it is either reinstalled or the folder ...AppData/Local/Arduino15 is deleted.

Solution: Ensure that Java is allowed network access in your computer's firewall settings.

Why doesn't my SD card work? It may be fake.

Description: We have had customers contact us regarding SD card problems with M2. On rare occasions it would seem that an SD card will flatly refuse to work with M2, without any apparent rhyme or reason. Sometimes they are unbranded generic cards and sometimes they are well-known name brands. Sometimes they are slower cards and sometimes they are faster cards. In all the time we have tracked complaints about SD card problems we have noticed one unifying theme: there is no unifying theme.

Solution: That’s a little hard to believe, so we set out to do some random testing. We bought a handful of SD cards from a handful of vendors, and tested each card straight out of the packaging directly in M2. We also tested all of the cards on a Mac with an SD card reader, using “Disk Speed Test” by Blackmagicdesign.

Of the six SD cards, two failed in M2 outright and posted extremely poor performance in Disk Speed Test. Both were Sandisk Ultra-branded and purchased from the same source, but another Sandisk Ultra purchased from a different source performed perfectly.

It did not appear to be a question of class of card, which leads us to believe that the only way to get both failed cards to operate so poorly and nearly identically MIGHT be if the cards are fakes. The random internet budget vendor who sold us the suspect cards may not even be aware that they are selling counterfeits that don’t work in many applications.

There are a LOT of good write-ups on the problem of counterfeit SD cards, but one that we found particularly detailed and useful is https://photographylife.com/fake-memory-cards.

TL;DR: There is almost nothing to prevent a customer from buying a fake card, so all you can do is buy from reputable sources with good return policies (such as the 8GB card we carry), and thoroughly test the card yourself!

As you work with the Digi modem, please keep in mind that it requires more power that your computer can provide directly over a USB port. You have 2 options:

• Power your M2 via the OBD2 port (i.e. plugging into your car or some sort of adapter)

• Use a powered USB hub. This option is preferable for desktop development. We've had good luck with this inexpensive hub:

https://www.amazon.com/AmazonBasics-Port-2-5A-power-adapter/dp/B00DQFGH80

Basic communication

A good first step is to check that everything is working it to talk to the modem from your computer, through your M2. For this, you need to program your M2 with a simple sketch that will forward data between the 2 serial ports:

• USBSerial, the USB connection between the M2 processor and your computer.

• Serial, the Serial connection between the M2 processor and the XBee socket pins

This sketch will also make the GREEN LED blink as the associate pin of the modem toggles. The pin signals and locations for the modem can be found here.

The second part to a basic communication test is the software on your computer. Digi offers a nice UI called XCTU to communicate with their products. Download the latest verison.

Once downloaded and installed, launch XCTU and follow the instructions from Digi's documentation.

From there, you can do all sorts of fun things, from sending an SMS to connecting to servers to posting data to a website. Several examples are found on Digi's documentation page.

With the right code, A0 can be a WIFI access point hosting a webpage - not just some boring static website, but a fully dynamic, interactive website where any browser (laptop, tablet, cell phone) can be your digital dashboard!

At the heart of A0 is the powerful ESP32 microcontroller capable of interacting with the car via CAN and be a fully functional WIFI access point at the same time. You connect your phone to the A0 access point, pull up a browser and start interacting with your car.

In this demo, we are displaying Boost pressure in a sweet 2016 Ford Fusion by reading the Intake MAP value via OBD2 commands, subtracting the ambient pressure (hard-coded to whatever it was here in MN during our test) and spitting out websocket messages at 20Hz. We're also demonstrating how to send data to the A0 to toggle an LED via a button press on the phone.

This demo was hacked together starting with this project as a reference:

https://shawnhymel.com/1882/how-to-create-a-web-server-with-websockets-using-an-esp32-in-arduino/

The webpage hosted on the ESP32 has a gauge.js instance running and a Bootstrap CSS framework. To add more gauges, we'd need to start using JSON messages (or something similar) to update more than one gauge.

Here is the code we used in this demo:

Next steps:

This demo shows a basic implementation of how to use websockets to display a single gauge on a browser. Next step would be to add more gauges, line graphs, and improve user interface.

AWS integration 🕸️

Put your data in the cloud. We'll be posting more information here about some cloud projects.

Other Projects ideas:

1. BLE beacon

2. Bluetooth to phone connection.

3. OBD-II emulation on ESP32

Resellers

OBD3way Setup

CAN0H to CAN1H and CAN0L to CAN1L and place a termination resistor across these connections; see photos below for setup.

Test

Once everything is hooked up, we power up P1, and SSH into P1 in two windows at: 192.168.7.2 to control each CAN channel at the same time.

Below you can see each session. Note that you'll want to send the "candump ..." command before sending the "cansend ..." command in the other window.

*These functionalities are current as of version 0.1, however future versions may have expanded features.

ELM327 Emulation, Explained Extra Efficiently

Why would you want to emulate an ELM327 device? ELM327 is a closed-source black box interpreter chip (a PIC with some firmware) and you'd much rather know exactly what is being sent to and from your car, right?

Another answer is that now you can take advantage of the numerous existing, (semi) working and tested applications out there for every platform.

SavvyCAN

A Super Powerful CAN bus reverse engineering and capture tool written by Collin Kidder. Wireless Car Hacking!

LED Color Codes

• RED - Not connected (In WIFIMODE=2 you are creating an AP with the A0, so it will go green immediately because you're the AP)

• Green - Ready to connect to application

• Blue - Connected to application

• Purple - Update mode

Smartphone apps

A0 should be compatible with any ELM327 based app.

Android - Torque Lite can be found at the link below:

Search the Google play store for more options.

iOS - Software version 14 of iOS breaks support for A0. We are working to regain iOS support. For those interested in testing on 13 or older make sure your app settings are:

• Connection = WiFi

• IP address = 192.168.4.1

• OBD2 adapter port = 1000

Other ELM based software

A0 System Menu

Many low level configurations can be done via a Serial Terminal (Real-Term, Tera Term, Arduino Serial Monitor, etc). This includes turning ON and OFF WIFI and Bluetooth, setting CAN speed, and setting the WIFI password.

Here is the system menu:

To enter A0 System Menu using the Arduino IDE Serial Monitor, follow these steps:

1. If you don't already have the Arduino IDE installed, download and install the Arduino IDE from here.

2. Connect A0 to your computer with a USB cable (A0's LED should turn green)

3. Open Arduino IDE.

4. Select the port (port numbers change frequently, your port number will likely be different than the one pictured).

Open an Arduino Serial Monitor: (button in the upper right corner)

Set your baud rate to 1000000 if it is not already

Send a question mark (?) to open the Menu

On the left is the current setting. On the right in parentheses are the options. For example, BTmode=0 means Bluetooth is currently off. Send "BTmode=1" in the top line to turn it on. Send another ? to make sure the change was made.

Re-Flashing ESP32RET

ESP32RET is the firmware shipped pre-loaded on A0, follow these steps to return it back to that state.

1. Download the below Zip file

2. Extract the files

3. Plug A0 into your computer via USB

4. Run the correct file for your computer

   1. PC - Updater.bat

   2. MAC - Updater.sh

   3. Linux - Updater.command

5. A green light should appear on the A0

To compile the code yourself, find everything for ESP32RET here:

Feel free to make improvements, submit pull requests and post issues!

Putting your own code on A0 (using Arduino IDE)

Using Arduino to install your own sketch

The following steps are needed to get started programming on the Macchina A0 with the Arduino IDE:

1. Install the Arduino Desktop IDE

2. Install the Macchina A0 Board Configuration

3. Build and upload a sketch

Arduino Desktop IDE

Follow the official installation instructions for your operating system then return here to continue with Macchina A0 specific setup.

• Windows

• macOS

• Linux

Board Definition

Flashing A0

1. Make sure any dependent libraries are in your Arduino>Libraries folder

2. Connect A0 to your computer via a micro USB cable

3. In "Tools" set the Port

4. Select "ESP32 Dev Module" as board type

5. Upload a sketch

6. Press upload

Attached is a simple sketch "ColorPallette" for blinking the LED on A0 and the required "FastLED" Library (both need to be unzipped).

A0 OBD2 connector pinout

The OBD2 connector is a 16 pin connector that provides power and a data connection. The image below shows the pin orientation of this 16 pin connector.

This following table describes the functionality of each pin. Please note that A0 only supports a single channel of CAN (CAN0), the rest of the pins are provided for general reference.

A0 OBD2 pins

Processor

A0 has two PCBs; one contains the ESP32 processor module, while the other contains the OBD2 connector and interface electronics. The upper PCB has a single momentary pushbutton (requires removing the case to access) and a RGB LED clearly visible through the top of the smoked case. A0 can communicate via WiFi and Bluetooth, or using the built-in microUSB port.

A0 uses the very popular Espressif ESP32, both as the application processor and the WiFi/BT radio processor.

Here is the link to the Espressif ESP32-WROOM32 datasheet: https://www.espressif.com/sites/default/files/documentation/esp32-wroom-32_datasheet_en.pdf

Pin Mapping

Use the names in the "Mapped Pin Name" column in your Arduino Sketch.

A "pin mapping" describes how the different circuits of your M2 are connected to the processor. For example, the Green LED (DS6 on the schematic) is connected to pin 7 (AKA PA14) of the processor. To make things easier from a programming standpoint, we can map this to a pin name, in this case, the green LED is mapped to the name DS6 (which is compiled to the value 18).

CAN bus

CAN (Controller Area Network​) bus is a vehicle bus standard used in most cars built after 2006. It is a message-based protocol that allows modules within a car to communicate with one another. While the physical layer is understood and open, the actual meaning of the messages sent over the bus are not. While some messages are legislated to be "standard", the majority of CAN messages in your typical car are not well documented.

The A0 has 1 CAN channel that can interface directly to the CAN bus network of your car. The A0 uses an external TJA1051 CAN transceiver. Here is CAN interface schematic. Note that C19 and C20 are not populated on shipping hardware.

Here is the link to the TJA1051 datasheet: http://www.nxp.com/docs/en/data-sheet/TJA1051.pdf​

CAN bus connections can also be found on the 16-pin OBD2 connector.

Communication

WIFI and Bluetooth

ESP32 offers both WIFI and Bluetooth as wireless communication. More information here to follow.

USB

A0 has a USB connector that will provide communication to the ESP32 processor AND power to A0. Reflashing ESP32 can be done through the USB port. More information here to follow.

Power

Like all electronics, your A0 requires power to run. Your A0 can be connected directly to an OBD2 port for power. In addition, A0 can be powered via USB. If both USB power and OBD2 power are present, OBD2 power is prioritized.

Protection

A0 employs several circuits to protect the device from overcurrent, reverse voltage, and overvoltage.

Storage/ Memory

A0 uses the ESP32-WROVER-I with following memory size:

• 16MB (128Mb) external SPI flash

• 8 MB SPI Pseudo static RAM (PSRAM)

• A0 can also be custom ordered with additional solder down memory - Email [email protected] for more information

LED

A0 has an addressable RGB LED for programmable status indication.

Button

A0 has a single momentary pushbutton on the upper PCB, press it to reset the ESP32

Schematics

The schematics for the A0 boards are open source on GitHub​ here:

• microSD card (included in kit)

• WIFI dongle (included in kit)

• USB cable

Adapter board:

The adapter board plugs directly into the M2 Interface board and provides:

1. Routing of power and signals from M2 Interface board to PocketBeagle.

2. Battery connector for standard 2-Pin JST battery connector and single cell lithium battery. (Optional)

3. USB A host port with ESD protection.

4. Voltage scaling for 6 Analog inputs.

5. Several 0 ohm jumpers to route signals as needed.

Adapter PCB files are found at these links:

• Schematic

• Part location file

• Pin number file

P1 Setup:

Step 1: Hook stuff up.

The adapter PCB is pre-installed onto the M2 interface board. The PocketBeagle is also pre-installed onto the adapter board. Since the PocketBeagle is not keyed, if you remove, be sure to plug it in so that the USB ports are on the same side.

Step 2: Create a bootable SD card

Follow instructions here to create a bootable SD card. Once you have a bootable SD card, plug it into the PocketBeagle. Latest images are found here.

Plug a microUSB cable into the PocketBeagle and your computer. After a minute or so, use your favorite terminal to ssh to beagle.local or 192.168.7.2:

Login: debian Password: temppwd

NOTE: if 192.168.7.2 does not work then try 192.168.6.2

Step 2.5: Change your password (optional but recommended)

We want to make sure that others wont be able to access your device to do this the main thing we are going to do is change the root password.

Step 3: Connect to internet.

First thing we'll want to do is connect to the internet to be able to download the latest packages. To do that, we'll use WIFI. Type the commands as shown below

All of the hotspots that your setup can see will be listed here, and look something like this:

wifi_xxxxxx_xxxxxx_managed_psk

Run these commands to connect:

You should now be connected to your local WiFi. You can check that you have an IP address by typing the following in the terminal window:

You should now see an IP address under wlan0 and you can now connect to this IP address in the future to program your PocketBeagle.

If you have trouble with the WiFi connection after initial setup, then ssh over the USB cable to the BeagleBone and run:

Step 4: Update

After connecting to internet, we can update the PocketBeagle by running these two commands, this should take a few minutes.

Step 5: Set up pins

Next we make sure the pins on the PocketBeagle are set up correctly as shown at this link:

https://github.com/beagleboard/pocketbeagle/wiki/Peripherals#can

The following steps only need to be performed once. The correct pin configuration will then persist across reboots. Verify that that these files exist:

Edit the boot configuration so the CAN0 and CAN1 pins will be configured automatically:

replace these lines:

with these lines:

save the file (ctrl-o) and exit (ctrl-x) and then reboot:

Next, we set up the CAN interface and turn it on. Note that we are setting rate at 250Kb/s here. Your car might be a different BAUD rate.

Step 6: print out CAN messages

To see actual data, we need to do 2 things: 1. Plug M2/PocketBeagle into your car or an emulator (No need for hub, and WIFI dongle anymore - those can be unplugged) and 2. enter this command to print output to terminal screen:

If everything is set up correctly, you should see something like this:

While this looks pretty cool, it is hard to see what is going on. Press CTRL+C to end output to terminal.

Logging CAN data to a file makes it easier to analyze the data. To do that, use this command to log data to current working directory:

Optional:

Run these commands to enable the CAN1 interface and print anything received to the terminal:

Step 7: Sending CAN messages

This should be used for testing purposes only and caution should be taken before sending messages to a real car. Here are instructions on how to send CAN messages on the CAN0 interface.

Step 8: Going further.

You can test sending and receiving CAN a couple ways:

• Loopback test using a single P1.

• Use two sets of P1 and the OBD3way and 12V power supply.

• A real car! (More to follow)

Services Needed:

• Google Assistant

• If This then That (IFTTT)

• Adafruit IO

Theory

• Voice commands will be given to either a smartphone or a Google Home device

• Voice data is passed to Google Assistant

• Google Assistant then triggers IFTTT with either an ON or OFF command

• IFTTT in turn updates Adafruit IO with the ON or OFF command

• SuperB receives the ON or OFF command and updates itself to reflect the new state

• M2 reads the ON/OFF state of SuperB and then starts or stops the car

Implications, Expansion

• Other than Google Assistant, IFTTT supports a huge number of triggers. (e.g. weather, connect/disconnect from Wi-Fi networks, time, etc.) For example, have your car warm up before leaving for work if the temperature is below a certain threshold.

• Because the smartphone and SuperB are never directly connected, commands can be sent to the vehicle as long as both devices have an internet connection, regardless of the physical distance between them.

Google Assistant

You'll need either a smartphone capable of accessing Google Assistant or a Google Home device. In either case, make sure you know the credentials of the Google account associated with the device.

If This then That (IFTTT)

If This then That will handle the exchange between Google Assistant and Adafruit IO, and adds the option to use a trigger other than a voice command. Register for an account here. Make sure to link the same Google account used on your smartphone or Google Home.

Adafruit IO

Adafruit IO is an easy to use web service that can control internet enabled hardware (like M2 and SuperB). IO provides a virtual dashboard accessible through a web browser onto which all manner of gauges, sliders, buttons, and switches can be placed. For our purposes we'll have a dashboard with a simple ON/OFF switch, the state of which the SuperB will be able to read. What makes IO extremely useful is that these switches can be controlled by other web services like IFTTT, and not just through the web dashboard. Register for an account here.

Step 1: Set up Adafruit IO

Create a new feed titled "LED_Control". (case-sensitive!)

Create a new dashboard with any title.

Navigate to the new dashboard and place a toggle switch linked to the "LED_Control" feed. Leave the block settings on their default settings.

There should now be a single toggle switch on the dashboard:

Find and record your username and key, which will be necessary later.

Step 2: Set up and Test SuperB

Download the SuperB sketch here. (This sketch uses the Adafruit MQTT library which can be installed through the Arduino library manager)

Update the sketch with your Adafruit IO and Wi-Fi credentials.

To flash SuperB with M2 follow the instructions here. Alternatively, if you have an XBee USB adapter board you can flash SuperB using the instructions found here.

Power on SuperB (either with an M2 or USB adapter board) and use the Adafruit IO dashboard to test the functionality.

Step 3: Set up and Test IFTTT

Create a new applet with Google Assistant as the trigger (the "this").

Select Adafruit IO as the action (the "that"). Connect your Adafruit account to IFTTT if prompted. Select the "LED_Control" feed and enter "ON" (case-sensitive) as the data to save to the feed.

In the same style create another applet to turn the car off, sending "OFF" instead of "ON".

With these 2 applets you should now be able to control the toggle switch on your IO dashboard via Google Assistant.

Great! At this point we can toggle a pin on SuperB using Google Assistant. The final step is to have M2 read the pin state and then perform an action on the car accordingly.

If you're interested in using more than just one pin the SuperB pinout can be found here, and the pinout for the M2's XBee socket can be found here.

Step 4: Flash M2

Download the M2 sketch here.

This sketch uses the M2_12VIO library found here, the pwm library found here, and the mcp2515 library found here, make sure you have them installed.

Determine which version of M2 you have here. Comment out the V4 specific line in the readBatteryVoltage() function if you have V3 or earlier, otherwise leave the code as is.

The startCarSpecific() and stopCarSpecific() functions are pre-populated with GM specific CAN messages. You'll have to determine what CAN messages to send for other cars. (This may take some work to determine!)

• 2) Select "Macchina M2" as board type and upload the sketch below:

If you are looking to partner with Macchina or have us work on your product? go here

To find libraries for any M2 interfaces, try the Macchina Community Showcase.

26-pin general purpose connector

Every M2 has a 26-pin general purpose "expansion" connector that provides even more connection options. For example: UART, SPI, I2C, six general purpose 12V drivers and six 12V analog inputs. See the schematic for actual pinout details.

Part number for this 2mm pitch connector is: Hirose DF11-26DP-2DS(52)

Refer to the following diagram for pin 1 location. Note that the ODD pins are on the TOP row and the EVEN pins are on the BOTTOM row.

The following table shows what the function for each pin:

Find more about six 12V source/sink driver circuits here.

CAN

Controller Area Network

CAN bus is a vehicle bus standard used in most cars built after 2006. It is a message-based protocol that allows modules within a car to communicate with one another. While the physical layer is understood and open, the actual meaning of the messages sent over the bus are not. While some messages are legislated to be "standard", the majority of CAN messages in your typical car are not well documented.

The M2 has 2 CAN channels (in addition to the single-wire CAN channel) that can interface directly to the CAN bus network of your car. The M2 uses the 2 built-in CAN controllers found in the SAM3X and 2 external TJA1051 transceivers. Here is a typical example:

Here is the link to the datasheet: http://www.nxp.com/docs/en/data-sheet/TJA1051.pdf

CAN bus connections can be found on either the 16-pin OBD2 connector on the under-the-dash M2 or the 24-pin connector used by the under-the-hood M2.

Single-wire CAN

The Macchina M2 provides single-wire CAN support using a MCP2515 CAN controller.

LIN

Local Interconnect Network bus is an inexpensive, single wire, serial network protocol used in many modern cars. Typically, LIN would be used to control and monitor lower-priority devices such as seat positions, door locks, radio and illumination.

The M2 has 2 LIN channels that can interface directly to the LIN bus network of your car. Your M2 uses 2 external TJA1027 transceivers connected via UART to the processor.

Here is the link to the datasheet: https://www.nxp.com/docs/en/data-sheet/TJA1027.pdf

Note that the TJA1027 transceiver is used for both LIN and ISO9141 (K-LINE/L-LINE) for a total of 2 channels.

LIN bus connections can be found on either the 16-pin OBD2 connector on the under-the-dash M2 or the 24-pin connector used by the under-the-hood M2.

K-line (aka ISO9141, KWP2000)

ISO9141/K-line is typically found in Chrysler, European, and Asian vehicles built before around 2005. This protocol is similar to RS-232 but at different voltage levels and on a single, bidirectional line.

Some cars require a secondary line (sometimes referred to as L-Line).

M2 has two K-line channels and uses the TJA1027 transceiver to interface the 12-volt single bidirectional line from the vehicle to a 3.3V UART connection. While this part is designed for LIN, it is also K-line compatible. Here is typical interface circuit showing a channel of ISO9141/LIN connected to the UART channel of the processor.

K-line connections can be found on either the 16-pin OBD2 connector on the under-the-dash M2 or the 24-pin connector used by the under-the-hood M2.

Here is the link to the datasheet: https://www.nxp.com/docs/en/data-sheet/TJA1027.pdf

J1850

M2 supports both J1850 PWM (Pulse-width-modulation) and VPW (Variable Pulse width).

J1850 PWM is typically found in older Ford vehicles and operates at 41.6 kb/s. The bus is active when J1850+_BUS is pulled HIGH to 5V and J1850-_BUS is pulled LOW to 0V.

J1850 VPW is typically found in older GM vehicles and operates at 10.4 kb/s.

The voltage range for each protocol is different (0-7V for VPW and 0-5V for PWM). To change between the levels required for PWM and VPW variants of J1850, use this signal:

J1850_PWM_VPW (M2 board signal name "J1850_PWM_nVPW")

This signal is connected to physical pin 123 (PB8) of the SAM3X. Make this pin HIGH for PWM and LOW for VPW

The following code that will both turn on power to J1850 circuit AND set level for either PWM or VPW:

These signals originate from the vehicle:

J1850+_BUS connects to pin 2 on the OBD2 port and is used by BOTH J1850 PWM and VPW.

J1850-_BUS connects to pin 10 on the OBD2 port and is used by J1850 PWM

These signals connect to the processor as OUTPUTS:

J1850P_TX (M2 board signal name "J1850+_TX") is an OUTPUT from the processor used for BOTH J1850 PWM and VPW. "J1850+_TX" is connected to pin 45 or PC18. This corresponds to the PWMH6 on peripheral B.

• With J1850_PWM_VPW = HIGH (i.e. PWM mode): When this signal goes HIGH , pin 2 of the OBD2 connector is 5.5V. When this pin is LOW, pin 2 of the OBD2 connector is 0V.

• With J1850_PWM_VPW = LOW (i.e. VPW mode): When this signal goes HIGH , pin 2 of the OBD2 connector is 7.5V. When this pin is LOW, pin 2 of the OBD2 connector is 0V.

J1850N_TX (M2 board signal name "J1850-_TX") is an OUTPUT from the processor and is used for J1850 PWM. "J1850-_TX" is connected to pin 7 or PC23. This corresponds to the PWML6 on peripheral B.

• With J1850_PWM_VPW = HIGH (i.e. PWM mode): When this signal goes HIGH , pin 10 of the OBD2 connector is 0V. When this pin is LOW, pin 10 of the OBD2 connector is 5V.

PWMH6 and PWML6 functionality is described in section 38: Pulse Width Modulation (PWM) of the SAM3X datasheet.

These signals connect to the processor as INPUTS:

J1850_PWM_RX is an INPUT to the processor. "J1850_PWM_RX" is connected to pin 3 or PC28. This corresponds to the TIOA7 on peripheral B.

J1850_VPW_RX is an INPUT to the processor. "J1850_VPW_RX" is connected to pin 4 or PC26. This corresponds to the TIOB6 on peripheral B.

TIOB6 and TIOA7 functionality is described in section 36: Timer Counter (TC) of the SAM3X datasheet.