STM Micro-controllers

Here is the Quick Start Guide for the STM32 family:




public defn micro-controller (params:Tuple<KeyValue>) -> (Tuple<KeyValue<Symbol,?>> -> Instantiable)

Calling micro-controller will lookup a micro-controller from the JITX Parts Database. The component is wrapped inside a pcb-module generator. micro-controller calls the Part Query API with the list of attributes provided by the argument parameters and design variables. This function requires internet access to succeed.


defpackage main :
  import core
  import jitx
  import jitx/commands

  ; Required: import the micro-controllers package that defines the generator
  import ocdb/utils/micro-controllers

pcb-module my-design :
  ; ... 

  ; First, we specify the list of query parameters to query an MCU
  val query-params = [
    "core" => "ARM Cortex-M3"
  ; Next we look up the MCU generator using our query parameters.
  val mcu-generator = micro-controller(query-params)

  ; Next, we specify the generator params. This tuple may be empty.
  val generator-params = [
    `cap-bypass-package => 4.7e-6

  ; Finally, we can call the generator and add it to our design.
  inst mcu : generator(generator-params)

  ; ...

micro-controller(["core" => "ARM Cortex-M3"]) is a module generator for an STM micro-controller based on the ARM Cortex-M3. It optionally can be run with argument [`cap-bypass-package => 4.7e-6] for our micro-controller API to generate a module with the required configuration and requested capacitance for the package power supply bypass.

See the supported parameters for available query and generator parameters.

MicroController Struct

public defstruct MicroController <: Component :
  ; Generic properties
  manufacturer: String
  mpn: String
  trust: String
  x: Double with: (as-method => true)
  y: Double with: (as-method => true)
  z: Double|False
  mounting: String
  rated-temperature: MinMaxRange|False
  ; Specific properties
  core: String
  core-architecture: String
  data-width: Int
  flash: Double
  frequency: Double
  io: Int
  line: String
  mfg-package: String
  ram: Double
  eeprom: Double
  series: String
  supply-voltage: MinMaxRange
  rated-esd: Double|False
  sellers: Tuple<Seller>|False with: (as-method => true)
  resolved-price: Double|False with: (as-method => true)
  pin-properties: STMPinProperties
  bundles: Tuple<STMBundle>
  supports: Tuple<STMSupports>

public defstruct MinMaxRange :
  min: Double
  max: Double

The MicroController struct represents a micro-controller that can be converted into an instance or module. micro-controller parts queries will populate the fields of this struct. Solvers may use this struct to access data without routing calls through the JITX language.


Takes a MicroController struct and returns an Instantiable.

defmethod to-jitx (m: MicroController) -> Instantiable


defpackage my-design :
  import core
  import collections
  import jitx
  import jitx/commands
  import ocdb/utils/db-parts
  import ocdb/utils/micro-controllers

pcb-module my-module :
  val mcu = MicroController(["max-io" => 40])
  inst res : to-jitx(micro-controller)

MicroController Query API

defn MicroController (parameters:Tuple<KeyValue>) -> MicroController

defn MicroController (parameters:Tuple<KeyValue>,
                      exist:Tuple<String>) -> MicroController

defn MicroController (parameters:Tuple<KeyValue>,
                      operating-temperature:[Double, Double]|False) -> MicroController

Create a Microcontroller struct object from a set of query parameters using the Part Query API. This call requires internet access to reach the JITX parts database.


  • exist: We can require the resulting micro-controller to have an attribute that is otherwise optional (for example "tolerance").
  • sort: overrides the sorting arguments that would otherwise be OPTIMIZE-FOR.
  • operating-temperature: overrides the rated temperature range that would otherwise be OPERATING-TEMPERATURE.

See the supported query parameters for available arguments to the parameters field.


Example: Find the best micro-controllers for our design requirements (optimizes by area by default, which is configured in `ocdb/utils/design-vars')

defpackage mcu-query :
  import core
  import collections
  import jitx
  import jitx/commands
  import ocdb/utils/micro-controllers

val mcu = MicroController([])
  mpn = STM32L031G6U6
  trust = low
  (x, y, z) = (4.0, 4.0, 0.55)
  mounting = smd
  rated-temperature = MinMaxRange(min=-40.0, max=85.0)
  core = ARM Cortex-M0+
  core-architecture = ARM
  data-width = 32
  flash = 16000.0
  frequency = 32000000.0
  io = 21
  line = STM32L0x1
  mfg-package = UFQFPN28
  ram = 8000.0
  eeprom = 1024000.0
  series = STM32L0
  supply-voltage = MinMaxRange(min=-40.0, max=85.0)
  rated-esd = 2000.0
  sellers =
      company-name = Mouser
      resolved-price = 2.55
      offers = (
          inventory-level = 110
          prices = (
            SellerOfferPrice(quantity = 1, converted-price = 3.29)
            SellerOfferPrice(quantity = 10, converted-price = 2.96)
            SellerOfferPrice(quantity = 50, converted-price = 2.96)
            SellerOfferPrice(quantity = 100, converted-price = 2.55)
            SellerOfferPrice(quantity = 250, converted-price = 2.4)
            SellerOfferPrice(quantity = 500, converted-price = 2.11)
            SellerOfferPrice(quantity = 1000, converted-price = 1.83)
            SellerOfferPrice(quantity = 5880, converted-price = 1.82)
            SellerOfferPrice(quantity = 10000, converted-price = 1.83)))))
  resolved-price = 2.55)
public defn MicroControllers (properties:Tuple<KeyValue>, exist:Tuple<String>) -> Tuple<MicroController>

Similar to MicroController but querying up to 25 micro-controllers (note the trailing s).

public defn MicroController (raw-json: JObject) -> MicroController

Creates a MicroController from a JObject.


defpackage query-mcu :
  import core
  import json
  import jitx
  import jitx/commands
  import ocdb/utils/db-parts
  import ocdb/utils/micro-controllers

val result = dbquery-first(["category" => "microcontroller" 
                            "flash" => 32.0e3
                            "_stock" => 1, 
                            "_sellers" => ["Mouser"]  ])

val mcu = MicroController(result as JObject)
  mpn = STM32L010C6T6
  trust = low
  (x, y, z) = (9.0, 9.0, 1.6)
  mounting = smd
  rated-temperature = Toleranced(-40.0 <= 22.5 <= 85.0)
  core = ARM Cortex-M0+
  core-architecture = ARM
  data-width = 32
  flash = 32000.0
  frequency = 32000000.0
  io = 38
  line = STM32L0x0
  mfg-package = LQFP48
  ram = 8000.0
  eeprom = 256000.0
  series = STM32L0
  supply-voltage = MinMaxRange(min=1.8, max=3.6)
  rated-esd = 2000.0
  sellers = 
      company-name = Mouser
      resolved-price = 2.89
      offers = (
          inventory-level = 2
          prices = (
            SellerOfferPrice(quantity = 1, converted-price = 2.89)
            SellerOfferPrice(quantity = 10, converted-price = 2.61)
            SellerOfferPrice(quantity = 25, converted-price = 2.46)
            SellerOfferPrice(quantity = 50, converted-price = 2.46)
            SellerOfferPrice(quantity = 100, converted-price = 2.1)
            SellerOfferPrice(quantity = 250, converted-price = 1.97)
            SellerOfferPrice(quantity = 500, converted-price = 1.73)
            SellerOfferPrice(quantity = 1000, converted-price = 1.43)
            SellerOfferPrice(quantity = 3000, converted-price = 1.31)
            SellerOfferPrice(quantity = 10000, converted-price = 1.31)))))
  resolved-price = 2.89)


public defn look-up-micro-controllers (attribute: String) -> Tuple
public defn look-up-micro-controllers (attribute: String, filter-properties:Tuple<KeyValue>) -> Tuple

Looks up the list of available query results for attribute amongst micro-controllers in the JITX database. Results are capped at 1000. This call filters on the same properties as MicroController. Additional properties filter-properties can be given in argument to restrict further criteria on the considered micro-controllers.


defpackage lookup-micro-contollers :
  import core
  import jitx
  import jitx/commands
  import ocdb/utils/micro-controllers

; Query available cores in the JITX Parts Database
val available-cores = look-up-micro-controllers("core")

; Print them out
println("Available cores:")
for core in available-cores do :
  println("  %_" % [core])

This function is useful for querying the currently available components in the JITX parts database.



defn mcu-module (component:Instantiable) -> (Tuple<KeyValue<Symbol,?>> -> Instantiable) :

Create a microcontroller module generator from a component generated with to-jitx from a MicroController object.


defpackage create-mcu-module :
  import core
  import collections
  import jitx
  import jitx/commands
  import ocdb/utils/db-parts
  import ocdb/utils/micro-controllers
  import ocdb/utils/stm-to-jitx

pcb-module my-module :
  ; First create a MicroController object
  val mcu-object = MicroController(["core" => "ARM Cortex-M3"])

  ; Then create an MCU instance
  val mcu-instantiable = to-jitx(mcu-object)

  ; Now we can create an mcu-module generator
  val mcu-module-generator = mcu-module(mcu-instantiable)

  ; And finally, create the module by calling the generator.
  inst mcu : mcu-module-generator([])

micro-controller is a wrapper around the logic above.

Supported Parameters

Supported Micro-controller Query Parameters

"manufacturer"StringThe name of the manufacturer, for example `"STMicroelectronics"
"mpn"StringThe MPN of the device.
"line"StringThe product line of the device.
"series"StringThe product series of the device.
"core"StringThe core of the device, for example "ARM Cortex-M0".
"core-architecture"StringThe ISA of the device, for example "ARM".
"data-width"DoubleThe data width of the device.
"frequency"DoubleThe core frequency of the device.
"io"DoubleThe number of GPIOs on the device.
"flash"DoubleThe amount of flash memory on the device.
"ram"DoubleThe amount of RAM on the device.
"eeprom"DoubleThe amount of EEPROM on the device.
"rated-esd"DoubleThe ESD rating of the device.
"supply-voltage"[Double, Double]The [min, max] voltage supply requirements of the device.
"mfg-package"StringThe package of the device.
"rated-temperature"[Double, Double]The rated temperature of the device. Set by default with [../utils/].
"dimensions"[Double, Double, Double, Double]The [x, y, z, area] parameters of the device.
"mounting"StringThe mounting of the component, for example "smd" or "th"

Supported Micro-controller Module Generator Parameters

`reset-pullupDouble10.0e3OhmsThe pullup resistor value on the reset pin and power.
`reset-capDouble10.0e-9FaradsThe capacitor value between the reset pin and power.
`p-bypass-packageDouble4.7e-6FaradsThe bypass capacitor value between the package power supply and ground.
`p-bypass-pinDouble100.0e-9FaradsThe bypass capacitor value between every power pin and ground.
`boot-from"flash", "system", "sram""flash"The boot configuration option.
`boot-resistorDouble10.0e3OhmsThe boot pin resistor value.
`debug-interfaceBundleswd()The desired debug interface.
`debug-connectorInstantiableocdb/components/tag-connect/TC2050-IDC-NL/moduleThe desired debug connector.
`HSE-freqDouble16.0e6HzHigh-frequency clock configuration
`HSE-ppmDouble30.0e-6parts per million
`HSE-source"crystal", "osc""crystal"
`LSE-freqDouble32.768e3HzLow-frequency clock configuration
`LSE-ppmDouble0.05parts per million
`LSE-source"crystal", "osc""crystal"

See the Parts Query API for a detailed reference on parts database queries.