thingSoC Frequently Asked Questions (FAQ)
- Q: What is thingSoC?
thingSoC is an open source standard that defines a vendor independent socket system for the creation of new Internet Things; it addresses many of the limitations of current product offerings and standards, by adding capabilities such as automatic device discovery, device configuration, monitoring, instrumentation, and testing.
thingSoC works with many existing standards and Integrated Development Environments (IDEs), such as Arduino, rfDuino, Raspberry Pi, Beaglebone, X-Bee, and others; but adds features and capabilites that make building new IoT devices much easier.
The thingSoC virtual platform definition supports a number of different System-on-Chip platforms and peripherals, such as cell modems, packet radios, Wi-Fi, Bluetooth, and more.
- Q: Why create a new standard? Why not just use Arduino, or Beaglebone, or another existing standard?
thingSoC includes several capabilities that the other small form factors do not support :
- Production Ready, embeddable hardware platforms that are easy to use
- Standardized auto-discovery firmware system that identifies what boards are installed
- "RF Zones" specification for supporting on-board antenna and RF interfaces
- Built in support for battery, solar, and very low power applications
- High Speed Interface support, including SuperSpeed USB 3.0, PCI-E, and 10/100 Ethernet
- Standardized Mounting System, designed for high vibration platforms (robots, ebikes, drones)
- Standardized testing, instrumentation, monitoring, and data recording interfaces
- Interchangeable platform for break-out-boards, sensors, radios, and other devices
thingSoC is a completely open source standard, not tied to any proprietary vendor implementation, CPU architecture, or IDE. thingSoC is designed to be backward compatible with Arduino, rfDuino, Raspberry Pi, Beaglebone, X-Bee, and others.
- Q: Is thingSoC hardware, firmware, or software?
- All of the above. thingSoC defines a physical, hardware socket system for inter-operable printed circuit boards, with a data centric firmware model for automatic device discovery, and a software API for interacting with the system.
- Q: What are thingSoC Reference Designs?
- thingSoC Reference Designs are example thingSoC Compliant PCB designs that demonstrate particular functions or interfaces. Please see the thingSoC Github repo for a list of available thingSoC Reference Designs.
- Q: Are there any licensing fees for using thingSoC in my own products?
- No. thingSoc is a completely open standard, and there are NO licensing costs for adopting the thingSoC standard. If you want to design your own thingSoC based product, you are free to do so. If you want to make and sell your own copies of the thingSoC Reference Designs you are free to do so.
- Q: What interface standard does thingSoC support?
- thingSoC sockets support both the basic low speed interface standards like I2C, SPI, and UART,
but also supports higher speed interfaces like USB 3.0, 10/100/1000, and PCI-E for higher performance IoT devices.
The following diagram shows the basic interfaces by group, and color-coded :
- Q: How big are the thingSoC modules?
- thingSoC modules come in standardized sizes with specified mounting hole patterns.
A single thingSoC Breadboard module is 1.2 inches x 1.75 inches.
A thingSoC Embedded Module is smaller, at 31.75mm long by 22.86mm wide (1.25 inches x 0.9 inches).
The default sizes have been chosen as a best compromise between cost, ease of assembly and ease of use. They have also been chosen to be compatible with a wide variety of existing packaging options.
- Q: How many pins do thingSoC modules have?
thingSoC modules can be from a minimum of six(6) pins to a maximum of sixty-four(64) pins per
individual socket. The thingSoC module pin variations are known as "Pin Configurations", and support :
- 6 Pins - The Minimum Pin Configuration
includes Vin, Vbat, 5V, Ground, I2C1_SDA, and I2C1_SCL, to form a bare minimum connection. The I2C bus is used for both configuration information and data exchange.
- 24 Pins - The BreadBoard Basic Pin Configuration
adds UART and SPI bus pins for higher speed data exchange.
- 32 Pins - The Embedded Module Pin Configuration
adds JTAG for in-system programming.
- 64 Pins - The Maximum Pin Configuration
adds second UART, and Second SPI ports.
- 6 Pins - The Minimum Pin Configuration
- Q: What kind of connectors do thingSoC modules use?
thingSoC modules can have different I/O connector type "bindings", in order
to facilitate specific user requirements. The default thingSoC I/O connector binding is
the "BreadBoard" type, which employs common 2.54mm pitch (0.1 inch) female header and male pin connections,
and as the name suggests, is capable of being used with commonly available 2.54mm pitch breadboards and prototyping boards.
Pin-Through-Hole (PTH) types, Surface Mount Device Top layer mounting types (SMD-TOP), and Surface Mount Device Bottom layer mounting types (SMD-BOT) are available in the thingSoC PCB libraries, giving thingSoC users a wide variety of connector choices. A Pogo-Pin ("PP" type) I/O connector type "binding" is also included in the thingSoC specification, in order to facilitate the creation of thingSoC "TEST" modules for production testing applications.
Other I/O connector type "bindings" are possible, and may be added to the thingSoC specification at some future date.
- Q: What are thingSoC module "stacking levels"?
thingSoC module "stacking levels" refer to the type of board function, and it's vertical position in the physical stack of modules.
- EXPA - EXPAnsion levels
Any level above the "BASE" level is refered to be an "EXPA", or EXPAnsion level module. "EXPA" level modules use either "stack-thru" female header connectors, or surface mount (SMD) female headers on the top side of the board and surface mount (SMD) male pins on the bottom side of the board. The majority of thingSoC modules are "EXPA" level modules. A maximum of four (4) "EXPA" level modules can function in any thingSoC "BASE" socket (i.e. maximum stack height of four (4) "EXPA" level modules in any single thingSoC Socket).
- BASE - BASE Level
There will be only one "BASE" level per thingSoC socket stack, and it generally contains the application processor and it's support subsystems. "BASE" level modules use either "stack-thru" female header connectors, or surface mount (SMD) female headers on the top side of the board and surface mount (SMD) male pins on the bottom side of the board.. Please note, this is very different than other small form factors systems, such as the Arduino, that treat the processor board (Uno, Leonardo, Due, etc.) as the bottom of the stack. Most thingSoC "BASE" level module implementations will utilize surface mount (SMD) female headers on the top side of the board, and leave the bottom connectors pads bare, (i.e. no male pins on bottom) in order to utilize Pogo-Pin ("PP") style test connectors on the "TEST" level.
- TEST - TEST Levels
Any level below the "BASE" level is refered to as an "TEST" level module. "TEST" level modules implement test, measurement, and monitoring functions for the thingSoC "BASE" socket, and any attached "EXPA" levels. The "TEST" level modules can include JTAG programming, debugging, and trace functionality. Oscilloscopes, Logic Analyzers, Protocol Analyzers, Emulators, and similar functions are implemented as "TEST" level modules in the thingSoC standard.
"TEST" level modules eliminate common test lead/test jumper wiring and configuration problems by instrumenting standardized busses on known pins that can be easily probed and monitored. The thingSoC "TEST" level yields modular test and measurement platforms that are easily integrated for onsite or remote monitoring of devices and nodes.
Most thingSoC "BASE" level module implementations will utilize surface mount (SMD) female headers on the top side of the board, and leave the bottom connector pads unpopulated, (i.e. no male pins on bottom) in order to utilize Pogo-Pin style test connectors on the "TEST" level. "TEST" level modules are either "BB" type (Bread-Board) or "PP" type (Pogo-Pin). In order to reduce the cost of most "BASE" level modules, they will most commonly omit the bottom stacking pins, and expect that "PP" type (Pogo-Pin) "TEST" modules will be used. The "TEST" levels are an optional feature of the thingSoC standard, but present a consistant mechanism for adding instrumentation to a thingSoC socket, for testing and monitoring.
- EXPA - EXPAnsion levels
- Q: What do the terms "thingSoC Compliant" and "thingSoC Compatible" mean?
- thingSoC Compliant devices implement at least the the Minimum PinClass (0) of six (6) pins,
and the thingSoC EEPROM based autodiscovery mechanism in a thingSoC single, double, or triple sized PCB,
with specified mounting holes, and display the thingSoC logo on the silkscreen.
thingSoC Compatible devices may fit and interoperate with thingSoC based systems, but do not support the thingSoC EEPROM based autodiscovery mechanism or match the physical PCB size and specified mounting holes. This implies that thingSoC Compatible devices don't have access to thingSoC extended functions or display the thingSoC logo.
- Q: Is the thingSoC autodiscovery mechanism compatible with the Beaglebone Cape Manager?
- Yes. thingSoC Compliant devices implement the thingSoC EEPROM based autodiscovery mechanism, which is compatible with the Linux 3.8 Kernal and Device Tree Overlays. The thingSoC EEPROM based autodiscovery mechanism also implements additional features, however it is backward compatible with the Linux Beaglebone Cape Manager.
- Q: Are schematic and PCB layout library packages available for the different size thingSoC modules?
- Yes. The thingSoC Github repo contain schematic and PCB layout library packages.
- Q: What thingSoC modules are available to be purchased?
- The thingSoC team is currently working with several manufacturers to make thingSoC modules available for sale. We'll update this FAQ, as manufacturers announce their products and have stock of thingSoC modules available.