So I decided to pick a handful of PCBA services and order the same small board from them. Placing the same order with different services should allow me to compare quality, speed and costs between the different services.

In this post, I’m going to compare four assembly services for printed circuit boards. I got quotes from four services but placed orders with only three of them. One service (Seeedstudio) was simply too expensive for my little experiment.

All four services have a combined PCB/PCBA service. The services first manufacture the printed circuit boards and then they use the boards in a second stage to solder the components. Before you place the order you have to define the job with a couple of form fields. The required documents vary slightly from service to service but basically, you have to deliver Gerber files for the PCB stage and a detailed bill of material (BOM) in CSV or Excel format.

Two services also required a file which describes how to position the components with a pick-and-place machine, sometimes referred to as centroid files. CAD tools often can export this information. Eagle CAD, for instance, can do this with a few simple steps.

In the following paragraphs, I will describe the four services. At the end of this post, I will compare them side by side.

PCBWay

PCBWay offers a rich set of services: regular PCB manufacturing, SMD stencils, flexible PCBs, advanced PCBs as well ass PCB assembly.

For the initial price quote, you have to provide 4 numbers: quantity of boards for assembly, number of unique parts on one board, number of surface-mounted parts and number of through-hole parts.

You can then choose from three options how the components will be sourced: either PCBWay sources the parts for you or you send the parts to them. Or you provide some of them and PCBWay sources the rest.

For the initial quote, you also need to provide the size of the PCB and a couple of other aspects for PCB manufacturing. To get the final quote you need to have the Gerber files, a bill of materials (BOM) and a CSV file containing coordinates for the pick-and-place machine. The BOM is in Excel format. It’s best to download their Excel template and to provide the required information.

It took only a couple of hours until I got a reply from a PCBWay sales rep. The email contained an updated Excel file with costs per part. The sales rep asked me to check the BOM to make sure that they will source the correct components.

Since everything seemed to be as planned I paid. PCBWay has a wide range of payment options: PayPal, Credit Cards, Western Union and even Bank Transfer.

Production Phase

What I really liked about the PCBWay platform was the possibility to closely track the progress of the PCB order. The assembly doesn’t quite provide this level of information. I would assume that the IT system for PCB production is a lot more mature and integrated than the one for assembly. For my small quantity they probably even soldered by hand.

14 days after I placed the order I received an email with photos from some PCBs. I told them that they were not mine and they quickly fixed the mistake by sending photos of my order. With the photos you can verify that the first assembly is according to your plan before they continue with the rest.

A day later the PCBs were shipped by DHL to Switzerland. Another 3 days later the PCBs were in my inbox.

Note: for this order with PCBWay I had used a slightly different design than with the later providers. In this design, I had used the wrong coil and they were not able to fit the board. So, in the end, I wasn’t able to test the functionality of the board. However, this was my mistake, not PCBWay’s and I believe for this comparison this is irrelevant. For full disclosure, I thought you should know.

LocoPCB

LocoPCB is another manufacturer who also offers assembly services. Initially, I thought “Loco” stands for “low cost” but a closer look at their logo reveals a locomotive. So it’s relatively safe to assume that “loco” is short for locomotive.

Besides fun facts about their name, the ordering process for PCB and PCBA is very similar to PCBWay. They offer many options for the PCB manufacturing and for the assembly you can choose to provide parts by yourself, have them source the parts for you or a mix between the two. Minimal order quantity is 5 boards for both PCB manufacturing and PCB assembly. While in my first order I could profit from a discount for the assembly base fee the regular price is USD $50.

To get a quote you need to upload a ZIP file with the Gerber files. For PCB assembly an additional Excel file following their template has to be provided. The BOM has to contain the designator (e.g. C1, C2, etc.), a serial number of the part manufacturer, a column for quantities and additional description. You can use the description field to give them additional instructions per part. For instance, I wanted them to source the male header pins, but they should solder them. I wanted them to add the pins in the anti-static bag so the user could later decide if he needed the pins or not.

I placed the order in the evening (Central European Time) and the next morning I already had a response. They suggested replacements for some of the components in the BOM since they were easier to source.

All in all, they were very responsive during the order process. I had the feeling that their engineers were actually looking at the PCB design to make sure that the order would be completed as fast as possible in good quality.

Production and shipment were the fastest of the three tested services. Only 14 days after placing the order I had 10 perfectly looking boards in my mailbox. Quality was perfect and they worked as expected.

LocoPCB made to me the impression of a younger company than PCBWay but maybe I should explain this. On one hand, the LocoPCB IT systems are not as far integrated into the production process as PCBWays. While I could track every step of the production process with PCBWay the information available to me in LocoPCBs user interface was much more sparse. On the other hand, LocoPCB also seems younger because they were more eager to support me personally during the ordering process. This in my experience is usually the case for smaller and younger companies.

PCBGogo

PCPBGogo was the third service from where I ordered the Buck/Boost converter board. The required information to get a quote is nearly identical with the other two services. By filling out the number of boards, number of unique parts, number of SMD parts and number of through-hole parts you get a preliminary quote. For a full quote, you also need to upload Gerber files as well as a BOM-Excel in their format.

Parts can either be sourced by PCBGogo, by you or as a mix. Minimal order quantity is 5 boards. The user interface looks rather old and the email communication was not as personal as with the first two services.

After completing the first board they also sent me a photo for review:

PCBGogo was not only more expensive than PCBWay and LocoPCB but also much slower. It took 27 days from placing the order until the 10 boards were in my mailbox. So it took nearly twice as much time as with the fastest contender (LocoPCB).

Seeedstudio

If you are an electronics enthusiast like me you probably know Seeedstudio already. They have a shop with many cool gadgets to build fantastic projects. But did you know that they also offer a lot of other services? This includes PCB/PCBA, 3D printing, and kitting services. So being quite a fan of all that Seeedstudio does I wanted to include them in my little experiment.

Their PCB/PCBA order forms look suspiciously similar to the ones from LocoPCB and PCBWay and I wonder Seeedstudio actually sub-contracts one of the other two services to manufacture the PCBs. Even the BOM has exactly the same format as LocoPCBs. After placing the request-for-quote they didn’t respond for a long time. After asking them if they had forgotten my request they answered that they couldn’t source the component described as “Any 2.54mm pin header”.

Finally, I got a quote for USD $170, more than twice the price compared to the cheapest and fastest provider. So I decided to ditch Seeedstudio from my experiment, just far too expensive!

Elecrow

Update November 16, 2019: After I published the initial post somebody asked me in the comments if I had tried the Elecrow’s PCBA service. I thought, why not add more services to the post?

So I sent them exactly the same gerber and bom files and requested a quote. They responded relatively quickly and pointed out that they were not able to source one coil. It seems that my manufacturer part number had changed or that I had used the wrong name.

After providing the proper name they responded quickly with a quote by email. The price was USD $154 for 10 pieces on the upper end of the field. The high price was mostly driven by the relatively high assembly costs of USD $85, which already had a huge discount from the regular price of USD $140. Also, shipping costs drove the total price at USD $21.

Makerfabs

Update November 20, 2019: Since I published the initial version of this post I keep getting contacted by PCBA services to include them in my article. Jennifer from Makerfabs contacted me and I sent them exactly the same documents as the other services had received: Gerber files and the BOM table. They processed the request rather quickly. I submitted the documents on a Friday and on Monday I already had a quote.

The prices are quite comparable to PCBWay and LocoPCB. Since I already have quite a number of these Buck/Boost converters I haven’t actually executed the order. Because of this the table below doesn’t have any numbers about processing time.

Makerfabs doesn’t only help you to manufacture PCBs and does PCB assembly, they also offer other services. I asked them how much engineering of a ESP32 development board would cost. For USD $200 they would provide the following:

• Design of the board
• 3pcs PCBA samples
• Simple testing instruction for the board
• Schematics, PCB, Gerber and BOM files
• Fees for shipping the samples
• Lead time: 2-3 weeks

It can be quite interesting to get all this from one service. Makerfabs also offers 3D printing and CNC manufacturing but I haven’t asked for a quote there.

Comparison

The following table compares the four services side by side:

As you can see from the table the costs are distributed in different ways. PCBGogo, for instance, has reasonable component costs but exorbitant shipping costs. For exactly the same shipping service (DHL) as the other two contenders. LocoPCB has relatively high component costs but won the price category because of the one-time assembly-base fee discount. Without that LocoPCB would be level with PCBWay. PCBWay offered a good quote for the components but a relatively high price for the 10 PCBs.

Update August, 2020: Since I published this blog post we ordered many components with MakerFabs. Their customer support is excellent and the prices are also quite comparable with PCBWay or former LocoPCB. They manufactured the ePulse Board for us and we are very happy with the results. So my current recommendation is to go with MakerFabs.

Setting up a Loriot.io Account

Loriot.io is a cool Swiss startup located close to Zurich and they are proving the infrastructure for LoRaWAN applications. Beside their commercial offerings they also have a service which doesn’t cost you anything. But in return you have to contribute to the network by connecting your own LoRaWAN gateway. I’m not going into detail here how to do that but here is some additional information: I configured my existing TTN gatway with a Raspberry Pi Zero W and a IMST IC880A concentrator to forward packages also to the Loriot network. In order to do that I just had to alter the local_conf.json file: Loriot uses a slightly different gateway ID (with FFFF in the middle, the default with TTN is FFFE). I also had to add the Loriot servers to the same configuration file:

{
        "gateway_conf": {
                "gateway_ID": "XXXXXXFFFFXXXXXX",
                "servers": [
                  {
                        "server_address": "router.eu.thethings.network",
                        "serv_port_up": 1700,
                        "serv_port_down": 1700,
                        "serv_enabled": true
                },
                {
                        "server_address": "eu1.loriot.io",
                        "serv_port_up": 1780,
                        "serv_port_down": 1780,
                        "serv_enabled": true,
                        "keepalive_interval": 10,
                        "stat_interval": 30,
                        "push_timeout_ms": 100,

                        "forward_crc_valid": true,
                        "forward_crc_error": false,
                        "forward_crc_disabled": false
                }],
                "ref_latitude": 0,
                "ref_longitude": 0,
                "ref_altitude": 0,
                "contact_email": "",
                "description": "ttn-ic880a"
        }
}

After that you can create a free account on the Loriot.io page. Now setup the gateway and place the created ID in the local_conf.json file, assuming that you are using a similar setup like mine (I’m using a semtek packet forwarder). Now you can switch to the “Application” menu and select the “Sample Application”. Now click on “Enroll device”:

Enter your device ID in the form field and click “Enroll OTAA / ABP device”. In the first post I showed you how to figure out the device ID. Now navigate to “Devices” and click on the newly created device. Here you can find the DevEUI, AppEUI and AppKey which you’ll have to use in the next paragraph.

Setting up the Seeeduino Code

In order to have the Seeeduino read out the GPS coordinates and the temperature and humidity we have to install two libraries. Download the TinyGpsPlus library from http://arduiniana.org/libraries/tinygpsplus/ Then install also the DHT library from Adafruit from the library manager under Sketch > Include Library > Library Manager… Menu. Copy the code you previously generated in the Loriot.io interface when adding a new device.

//Download http://arduiniana.org/libraries/tinygpsplus/
#include <TinyGPS++.h>
#include <LoRaWan.h>
#include "DHT.h"


TinyGPSPlus gps;
#define DHTPIN A0 // what pin we're connected to

#define DHTTYPE DHT11 // DHT 11
 
DHT dht(DHTPIN, DHTTYPE);
char buffer[256];


void setup(void)
{
    SerialUSB.begin(115200);
    Serial.begin(9600);
    
    lora.init();
    
    memset(buffer, 0, 256);
    lora.getVersion(buffer, 256, 1);
    SerialUSB.print(buffer); 
    
    memset(buffer, 0, 256);
    lora.getId(buffer, 256, 1);
    SerialUSB.print(buffer);
    SerialUSB.println("That was the id");
    // void setId(char *DevAddr, char *DevEUI, char *AppEUI);
    lora.setId(NULL, "XXX", "XXX");
    // setKey(char *NwkSKey, char *AppSKey, char *AppKey);
    lora.setKey(NULL, NULL, "XXX");
    
    lora.setDeciveMode(LWOTAA);
    lora.setDataRate(DR0, EU868);
    
    lora.setChannel(0, 868.1);
    lora.setChannel(1, 868.3);
    lora.setChannel(2, 868.5);
    lora.setChannel(3, 867.1);
    lora.setChannel(4, 867.3);
    lora.setChannel(5, 867.5);
    lora.setChannel(6, 867.7);
    
    lora.setReceiceWindowFirst(0);
    lora.setReceiceWindowSecond(869.5, DR3);
    lora.setAdaptiveDataRate(false);
    
    lora.setPower(20);
    
    while(!lora.setOTAAJoin(JOIN, 20000));
    SerialUSB.println("After OTAA join");

    // Start DHT sensor
    dht.begin();
}

void loop(void)
{   
    while (Serial.available() > 0) {
      gps.encode(Serial.read());
    }
    if (gps.altitude.isUpdated()) {
      SerialUSB.println(gps.altitude.meters());
      SerialUSB.print("LAT=");  SerialUSB.println(gps.location.lat(), 6);
      SerialUSB.print("LONG="); SerialUSB.println(gps.location.lng(), 6);
      SerialUSB.print("ALT=");  SerialUSB.println(gps.altitude.meters());
      long latEncoded = (gps.location.lat() * 8388606) / 90;
      long lonEncoded = (gps.location.lng() * 8388606) / 180;
      SerialUSB.print("Lat encoded: "); 
      SerialUSB.println(latEncoded);
      SerialUSB.print("Lon encoded: "); 
      SerialUSB.println(lonEncoded);
      float h = dht.readHumidity();
      float t = dht.readTemperature();
      SerialUSB.print("Humidity is: ");
      SerialUSB.print(h);
      SerialUSB.print(", Temperature: ");
      SerialUSB.print(t);
      bool result = false;
      byte data[10] = {0};
      data[0] = h;
      data[1] = t + 100;
      data[2] = (byte) (latEncoded >> 16);
      data[3] = (byte) (latEncoded >> 8);
      data[4] = (byte) latEncoded;
      
      data[5] = (byte) (lonEncoded >> 16);
      data[6] = (byte) (lonEncoded >> 8);
      data[7] = (byte) lonEncoded;

      result = lora.transferPacket(data, 10);
      //result = lora.transferPacket(data, 10, 10);
      
      if(result)
      {
          short length;
          short rssi;
          
          memset(buffer, 0, 256);
          length = lora.receivePacket(buffer, 256, &rssi);
          
          if(length)
          {
              SerialUSB.print("Length is: ");
              SerialUSB.println(length);
              SerialUSB.print("RSSI is: ");
              SerialUSB.println(rssi);
              SerialUSB.print("Data is: ");
              for(unsigned char i = 0; i < length; i ++)
              {
                  SerialUSB.print("0x");
                  SerialUSB.print(buffer[i], HEX);
                  SerialUSB.print(" ");
              }
              SerialUSB.println();
          }
          delay(1000 * 60 * 5);
      }
    }
    
}

Setting Up the Spreadsheet

Log into your Google Docs account and create an new Spreadsheet

Give the Spreadsheet a meaningful name, e.g. LoriotLogger

You might also want to add the column headers:

Copy/paste them from here and insert them before all other rows.

Then go to Tools > Script Editor…

Replace the few lines of code with the code below:

// 2017 by Daniel Eichhorn, https://blog.squix.org
// Inspired by https://gist.github.com/bmcbride/7069aebd643944c9ee8b
// Create or open an existing Sheet and click Tools > Script editor and enter the code below
// 1. Enter sheet name where data is to be written below
var SHEET_NAME = "Sheet1";
// 2. Publish > Deploy as web app
//    - enter Project Version name and click 'Save New Version'
//    - set security level and enable service (most likely execute as 'me' and access 'anyone, even anonymously)
// 3. Copy the 'Current web app URL' and post this in your form/script action

var SCRIPT_PROP = PropertiesService.getScriptProperties(); // new property service

// If you don't want to expose either GET or POST methods you can comment out the appropriate function
function doGet(e){
  return handleResponse(e);
}

function doPost(e){
  return handleResponse(e);
}

function handleResponse(e) {
  Logger.log("arrived in handleResponse");
  var jsonData = JSON.parse(e.postData.contents);
  
  try {
    // next set where we write the data - you could write to multiple/alternate destinations
    var doc = SpreadsheetApp.openById(SCRIPT_PROP.getProperty("key"));
    var sheet = doc.getSheetByName(SHEET_NAME); 

    var nextRow = sheet.getLastRow()+1; // get next row
    var row = [];
    var headerRow = [];

    row.push(jsonData.rssi);
    row.push(jsonData.seqno);
    row.push(jsonData.data);
    var humidityHex = jsonData.data.substring(0, 2);
    row.push(parseInt(humidityHex, 16));
    var tempHex = jsonData.data.substring(2, 4);
    row.push(parseInt(tempHex, 16) - 100);
    var latHex = jsonData.data.substring(4, 10);
    var lonHex = jsonData.data.substring(10, 16);
    var latEncoded = parseInt(latHex, 16);
    var lonEncoded = parseInt(lonHex, 16);
    row.push((latEncoded / 8388606) * 90);
    row.push((lonEncoded / 8388606) * 180);

    row.push(jsonData.freq);
    row.push(jsonData.ack);
    row.push(jsonData.fcnt);
    row.push(jsonData.dr);
    row.push(jsonData.bat);
    row.push(jsonData.port);
    row.push(jsonData.snr);
    row.push(jsonData.EUI);
    row.push(jsonData.cmd);
    row.push(jsonData.ts);

    // more efficient to set values as [][] array than individually
    sheet.getRange(nextRow, 1, 1, row.length).setValues([row]);
    // return json success results
    return ContentService
          .createTextOutput(JSON.stringify({"result":"success", "row": nextRow}))
          .setMimeType(ContentService.MimeType.JSON);
  } catch(e) {
    // if error return this
    return ContentService
          .createTextOutput(JSON.stringify({"result":"error", "error": e}))
          .setMimeType(ContentService.MimeType.JSON);
  } 
}

Publish > Deploy as web app

• enter Project Version name and click ‘Save New Version’
• set security level and enable service (most likely execute as ‘me’ and access ‘anyone, even anonymously)
• Copy the ‘Current web app URL’ and post this in your form/script action

Give permissions to the script:

Copy the URL:

Connecting Loriot with your Google Spreadsheet

Switch again to the Loriot page in your browser. Navigate to the Sample App > Output page:

Click on the “Change button” and select HTTP Push. Now enter the address from Google Docs, when you published the app. Done, Loriot should now send the data to Google Docs! One Note: I was logged into two google accounts at the same time, so my URL generated had an additional “/u/1” and it started with https://script.google.com/macros/u/1/XXX. If your URL looks like this then remove the /u/1/ from the URL.

Starting the Seeduino

Now let’s see if the data arrives!

Hurray!

Visualize the data on Google Maps

Now to the finishing: let’s put the markers on a map! Google Spreadsheets only have very simple maps so navigate to https://www.google.com/maps/d/u/0/.

In the left menu select “Import” and select your Spreadsheet from Google drive.

Now select the “lat” and “lon” column as the coordinate columns and the seqno column for the title. Create the map and you get a wonderful representation of your geo fixes, sent over LoRaWan to Loriot.io, from there to a App Script instance, which inserted the data into a spreadsheet, and from there you imported the data into a map! Wow! If you got it to work you really made it!

Do you have questions about this post? Go over to https://support.squix.org and place it there so everyone can profit!

One of the perks of being a blogger is that from time to time you get some cool new hardware to review. Seeedstudio asked me if I would like to play around with their brand new LinkIt 7697 and hey, I can almost never say NO to a shiny new gadget!

The Peripherals

The module has a luxurious set of available pins and just like the ESP8266 and the ESP32 many of them have more than one function. Starting with regular GPIO pins with PWM support (18 pins) to UARTs, ADC, hardware I2C and SPI and some more exotic ones like IrDA and I2S. The Cortex-M4 core is running with 192MHz which should give you plenty of power for more complex operations and also has a floating point unit (FPU) in case you need to do extensive math operations.

With 4MB of flash memory it can take your regular programs and art work without any problems, telling from my experience with the ESP8266 connected to displays.

If you want more details about the specs go to the product page.

Something practical – Controlling LED over Bluetooth

The LinkIt 7697 can currently programmed by three different platforms: One is based on FreeRTOS which aims at professional embedded developers, one for the Arduino IDE and one for a graphical editor called BlocklyDuino editor, ideal for kids. In the following examples I chose the Arduino IDE since it is a good mix between removing complexity while still having access to all the hardware features.

Installation is easy and painless when you follow this guide and very similar to the ESP8266 setup:

• Add the JSON Url to the Arduino preferences
• Pick the LinkIt board from the board manager
• Select the LinkIt board from the available boards in the Tools menu

After choosing the LinkIt 7697 board new examples show up in the file menu. And these examples, especially the ones for Bluetooth Low Energy (BLE) are very helpful.  For the following demo I opened File > Examples > LBLE > Simple Peripheral, connected the module over USB and uploaded the sketch to the module.

This sketch advertises a BLE LED service which allows other devices to turn one of the on-board LEDs on and off. To test that I installed a iOS app called LightBlue which immediately displayed the service.

In the LightBlue app (and in many other BLE discovery tools) you can then send values to the device. Sending a “1” turns on the LED, a “0” turns it of. Simple as that! I have to say, this was very easy to accomplish!

I tried another experiment, but didn’t succeed. I probably don’t understand enough of the BLE protocol. I have some bluetooth devices like a Sensirion SHT31 BLE “Humigadget”. And I couldn’t get the LinkIt 7697 to see it. While I see the device on the iOS app I cannot see it in the output of the test devices. It also seems not to update the list of discovered devices once it has taken them into the list. You can tell this because the RSSI should be fluctuating…

Comparison of the LinkIt 7697 and the ESP32

As mentioned initially the two chips have many things in common, GPIO pins and types, memory, connectivity (BLE and WiFi). While the LinkIt’s development platform for the Arduino looks really mature the ESP32’s is far from this state. You have to install it with a git checkout (instead of just pasting the URL in the Arduino preferences) and some APIs like the one for BLE are not even implemented yet.

Summary

The LinkIt is certainly an interesting option if you want to get started with a development module and BLE right away. I would like to find out why my BLE gadgets didn’t show up in the scan. It might be due to a bug in the BLE API or the represent a type of Bluetooth device which cannot be seen the by the LinkIt module. The quality of the examples is really good and it is really easy to setup the Arduino IDE to develop with the LinkIt module. I would like to see the ESP8266 lend some ideas from here. For instance the Serial baud rate seems to get detected automatically with the LinkIt setup, while I have to set this manually in the ESP8266 setup. And I have tested this with ESP8266 modules which also had a CP2102 serial-to-usb converter just like the LinkIt 7697. So give this Seeedstudio/MediaTek module a shot. You can buy it from Seeedstudio here.