1. Fail Fast and Fail Often

A classic engineering motto. No matter how precious your product may be, it’s always best to push it to its limits and see where improvements or fixes can be made. Be sure to include testing in your timeline, as unforeseen issues are bound to arise when developing products of all types. Having a dedicated engineering team for product design, testing and planning can be an invaluable addition, as you can expect your product to undergo fewer iterations, streamline the process, and ultimately save yourself both time and money.

2. Consider Support for Your Users

It’s very easy to get caught up in the excitement of developing a new product. So much so that it’s challenging to anticipate your customers’ needs once your product is in their hands. Support can look like replacing or repairing units, handling support cases, implementing firmware updates for quality of life, and a plethora of other tasks if IoT is involved. If you find yourself lacking the spare hands to tackle support requests, you always have the option to outsource work, even if temporary.

3. Backup Your Files

As a contractor, I’ve heard many horror stories of clients having lost their precious source code. Your future self will be so grateful that you took the extra precaution to keep the fruits of yesterday’s labor safe. This can apply to many different types of files: CAD, PCB design files, documentation, software/firmware, and much more. At DMC, we heavily utilize GitLab to track development and releases, but there are many other platforms to choose from. Once you adopt version control, long gone are the days of file names like “source files (final) (2) (fixed).zip”.

4. Identify Your Needs for Internal Teams

Depending on the intricacy of your product, you may need to employ dedicated teams to cover the different scopes involved. These teams may be involved with mechanical design, electrical design, firmware, backend software, and much more. To tie all these teams together, a project manager is essential for cohesion between teams.

5. What Does User Experience Look Like?

If a user needs to install your device, how can you simplify the process and minimize frustration? If your system is complex with multiple moving pieces, what user feedback is there to inform customers of proper use? The nature of user interaction varies widely from one product to another, but a polished and intuitive design is the ultimate driver of user satisfaction.

6. Determine Your Goals for Production

Find a unique balance between the cost per unit in materials, the cost for assembly, and components used. Optimizing these aspects will have a significant impact on the profitability and success of your product. 3D printing is fantastic for highly customized parts, but terrible for large-scale production. Drop-in off-the-shelf components may be a breeze to work with but may incur significantly higher production costs than a fully custom solution.

7. Do What You Can to Simplify Assembly

Assembly costs for a physical product can be a big budgetary blind spot. A robust and visually elegant design can still be one that is awkward to assemble, incurring exponential assembly costs. Whether you are assembling in-house or using a contractor, designing your product for ease of assembly will save you time and money in the long run.

8. What Technologies Are Associated With Your Niche?

If you’re serving a high-tech market, you need to keep up with the latest technological advancements. If you’re entering a market that is standardized in antiquity, you’ll need to be familiar with the nuances and pitfalls of its technology to ensure the success of your device. If you and your team lack the technical know-how, outsourcing is always an option to satisfy the needs of your niche, whether that is getting a second opinion or completely outsourcing a given aspect of your product’s development.

9. Does Your Device Need Any Certification Before It Can Hit the Shelves?

Many products need to be up-to-snuff with different regulatory bodies. If you aren’t sure what certifications you may need, looking at what your competitors are trying to meet is always a good starting point. Some regulatory bodies I have worked with are involved in communications and safety regulations, like the FCC and the CSA. Having a more intimate knowledge of the goings-on of these tests will ensure your device surpasses its requirements.

Main Takeaways

While this list is certainly not comprehensive, it hopefully got some gears turning. Knowing all the unknowns is unrealistic when you’re at the starting line, but you don’t have to be alone on your journey. DMC offers a wide range of services to help bring your product to life, from the idea’s initial conception to the final ‘IT’S ALIIIVVEE!’ moment.

If you’re ready to elevate your consumer electronics product, be sure to contact us today to see how we can help make your next project smoother, smarter, and way more gratifying.

The post 9 Things to Consider When Developing Consumer Electronics appeared first on DMC, Inc..

As a Chicago-based engineering firm specializing in embedded systems, industrial automation, and hardware-software integration, DMC has completed more than 10,000 projects across 40 countries. Our team is now focused on refining the motion systems and embedded intelligence that drive CardMill’s high-speed scanning and sorting capabilities.

We’re working alongside Beyond Design, a long-time collaborator with deep expertise in industrial design and user experience. Together, we form a synchronized team that’s fully integrated into CardMill’s development process.

Engineering for Performance and Scalability

We’re currently focused on refining the core mechanics that make CardMill powerful and reliable:

• Optimizing motion systems for smooth, consistent card movement
• Enhancing tray and feeder design for improved capacity and flow
• Evaluating cameras, motors, and processors to boost speed and reliability
• Strengthening alignment and durability for long-term performance

DMC and Beyond Design are also helping CardMill evaluate manufacturing partners to support tooling, pilot builds, and full-scale production. With over 60 years of combined experience, our teams are guiding the product toward a scalable and efficient manufacturing process.

Built for Collectors, Designed to Last

CardMill’s mission is to make high-performance card sorting accessible to everyday collectors. With DMC and Beyond Design leading the next phase, we’re confident the final product will deliver on that promise. The result will be an affordable, all-in-one scanner and sorter that’s built to last.

We’re proud to be part of this journey and look forward to sharing more updates as we move closer to delivery.

If you are charting a similar path from concept to production, connect with DMC to accelerate your project.

The post Partnering with CardMill and Beyond Design to Bring a Game-Changing Product to Market appeared first on DMC, Inc..

XPlanar

Beckhoff has generated quite a buzz with their new XPlanar system — taking the ability to move product off a conveyor or track and, instead, bringing it to a magnetic tile system with movers that fly above the surface with 6 degrees of freedom.

New applications and ways to apply the freedom provided by XPlanar are still being discovered; high-end assembly, pharmaceuticals, and laboratory/life science automation are among the popular use cases.

The XPlanar movers float and fly above tiles in a contactless manner. They allow two dimensional (X-Y) freedom of movement but can also move up and down in the Z-axis up to 5 mm. The tiles they travel across can be mounted at 90 degree angles or even upside down for some crazy creativity.

XPlanar Tile

Each mover can travel independently, allowing a lot of parallel multi-tasking and efficiency. They can also spin at up to 600 RPM, acting as a mixer or centrifuge (as shown below).

Mover Types

Note: the variants, speeds, payloads, surfaces, and dimensions show specifications that represent the maximum values which can be reached. Movers can be grouped to increase the total payload.

APM4220-0000-0000 | XPlanar mover, 0.4 kg payload

This is the smallest mover (about 4.5 inches squared) in the APM4xxx family and is compatible with all tiles of the type APS4xxx. The aluminum body is hard coated and can move at speeds up to 2 meters/second. This mover handles small, lightweight products (up to 0.4 kg) and can be used in bidirectional operation.

APM4221-0000-0000 | XPlanar mover, 1.0 kg payload

This mover is the second largest (about 5 inches squared) in the APM4xxx family and is very similar to the APM4220 other than its slightly larger size and an increase in payload (up to 1.0kg).

APM4330-0000-0000 | XPlanar mover, 1.5 kg payload

This mover is the all-rounder (about 6.1 inches squared) of the APM4xxx family and is also very similar to the APM4221. With a payload capacity of 1.5 kilograms, this mover is ideally suited for use as a universal tool to handle a wide variety of products. It is available in a stainless steel variant for applications with particularly demanding hygienic requirements.

APM4330-0001-0000 | XPlanar mover, 1.0 kg payload, stainless steel

This hygienic mover is completely encapsulated in stainless steel and designed to be easy to clean. At about 6.1 inches squared and with a payload capacity of 1.0 kilograms, it can move at speeds up to 2 meters/second. The mover is particularly suitable for all applications with particularly demanding hygiene requirements such as food and pharmaceutical applications.

APM4550-0000-0000 | XPlanar mover, 4.2 kg payload

This mover offers the highest payload (about 9.25 inches squared) of the APM4xxx family and is compatible with all tiles of the type APS4xxx. The aluminum body is hard coated and can move at speeds up to 2 meters/second. With a high payload capacity of 4.2 kilograms, the mover is suitable for handling larger and heavier products with few limitations

XTS

While there are a few different track-based transport systems in the market, Beckhoff’s eXtended Transport System (XTS) has some key advantages and differentiators. It’s very good for high-speeds (4 m/s 10G acceleration) and extreme repeatability and positioning (10 microns when stationary, and an amazing 0.15 mm of predictable positioning while in motion).

High-speed packaging machinery is a common application for XTS, along with assembly and laboratory projects. XTS is IP65 rated with IP69K hygienic options available as well. There are lower duty and heavier duty systems to accommodate different loads.

Comparing the Beckhoff and HepcoMotion systems

The Beckhoff-manufactured XTS guide rails and movers can carry loads between 1.8 to 2.75 pounds. With a track made of aluminum and matching movers that have plastic rollers, the lack of required lubrication allows this system to be used in the pharmaceutical industry — among others.

AT9014 | XTS Movers

This set of movers is ideal for higher payloads, higher mileage, and the smallest possible product spacing. The movers have a low overall weight and are available in 55mm and 70 mm lengths paths. The aluminum base body has partially plastic rollers and a magnetic plate set. With a high payload capacity of up to 1000 grams, the movers are suitable for flexible travel movements and individual travel paths.

XTS motor modules

XTS guide rails and movers

From our live demo: Beckhoff’s eXtended Transport System using an oval track.

Beckhoff teamed up with HepcoMotion to make a second, heavier duty XTS track option, the GFX. It allows you to mount a parallel Hepco guide rail system on XTS motor modules from Beckhoff, and it can carry loads of 11 – 33 pounds as the movers are made for increased payloads and longer service life.

Depending on your company’s load requirements, one of these two systems can be customized for your application. Another feature Beckhoff offers is the option to allow the movers to switch tracks within your system. Through XTS Track Management hardware and software, you can exchange and switch movers from track to track in multiple XTS linear transport systems, as shown below.

Picture and multimedia credits: Beckhoff Automation, all rights reserved. Beckhoff®, eXtended Transport System®, XTS® and XPlanar® are registered trademarks of and licensed by Beckhoff Automation GmbH.

Learn more about DMC’s Beckhoff expertise as part of the Beckhoff Integrator Group and contact us today to get started on your next project!

The post Beckhoff XPlanar & XTS appeared first on DMC, Inc..

Projects using MicroPython and JerryScript attempt to provide a means to write Python and JavaScript code and provide frameworks for “compiling” and running scripts on a variety of bare-metal targets. However, these types of frameworks have some inherent drawbacks. JavaScript and Python are both interpreted languages with garbage collection and weak typing. Running these languages requires relying on a run time or more complex cross compiler.

A New Language for Embedded Systems

More recently, Rust has emerged as an appealing language for applications that require memory safety and efficiency. Both of these features are often critical for embedded devices. Manual memory management often creates bugs which are hard to isolate and are not always easily remedied due to the resource constraints of embedded devices.

Additionally, C/C++, even given all of its faults, remains a highly efficient language due to the control it provides developers and because it can use many target-specific optimizations at compile time. C/C++ sets a high benchmark for speed that is difficult for interpreted languages to match.

Rust, fortunately, solves both problems in ways that are particularly well suited to microcontrollers. Rust does not require any run-time engine for garbage collection or memory management. Rust instead chooses to enforce memory safety at compile time. Furthermore, because Rust compiles to LLVM, target optimizations rivaling those achievable with C/C++ are possible. Recently, the Rust core team has made support for new target architectures a priority, and there are already many open source projects aimed at expanding support for embedded devices in Rust.

Nucleo PCB Running on Rust

Getting Started with Rust

The Embedded Rust Book provides many details regarding getting started with Rust on embedded devices. For this blog, I’ll highlight a few key components that make up the Rust embedded landscape. Specifically, I’ll be discussing support for ARM Cortex M based microcontrollers.

The Rust ecosystem is built on an extensive library of packages called “Crates.” A few specific crates, “cortex-m” and “cortex-m-rt”, make up the core support for ARM targets. These packages provide the bare minimum of code to get a basic program up and running. It allows access and control of the core ARM registers.

Below is an example of setting up the systick peripheral taken from the Rust Embedded Book.

use cortex_m::peripheral::{syst, Peripherals};
use cortex_m_rt::entry;

#[entry]
fn main() -> ! {
    let mut peripherals = Peripherals::take().unwrap();
    let mut systick = peripherals.SYST;
    systick.set_clock_source(syst::SystClkSource::Core);
    systick.set_reload(1_000);
    systick.clear_current();
    systick.enable_counter();
    while !systick.has_wrapped() {
        // Loop
    }

    loop {}
}

use cortex_m::peripheral::{syst, Peripherals};
use cortex_m_rt::entry;

#[entry]
fn main() -> ! {
    let mut peripherals = Peripherals::take().unwrap();
    let mut systick = peripherals.SYST;
    systick.set_clock_source(syst::SystClkSource::Core);
    systick.set_reload(1_000);
    systick.clear_current();
    systick.enable_counter();
    while !systick.has_wrapped() {
        // Loop
    }

    loop {}
}

To implement something more interesting than a simple timer, we’ll need a Peripheral Access crate. These crates are typically specific to a vendor and family of microcontrollers. For example, the STM32F4 crate provides an API for accessing various peripherals such as GPIO, UART, and I2C for the STM32F4 family of devices.

Pulling in a Peripheral Access crate, we can build a program for toggling an LED:

fn main() -> ! {
    let mut peripherals = stm32f429::Peripherals::take().unwrap();

    //Enable gpio b clock
    let rcc = &peripherals.RCC;
    rcc.ahb1enr.write(|w| w.gpioben().bit(true));

    //set pin 14 to output
    let gpio = &peripherals.GPIOB;
    gpio.moder.write(|w| w.moder14().bits(1));

    //Turn on led
    gpio.odr.write(|w| w.odr14().set_bit());

    loop {

        delay(10000);
        if  gpio.odr.read().odr14().bit()
        {
            gpio.odr.write(|w| w.odr14().clear_bit());
        }
        else {
            gpio.odr.write(|w| w.odr14().set_bit());
        }
        
    }
}

fn delay(count: u32) {
     for _ in 0..count { cortex_m::asm::nop() }
}

fn main() -> ! {
    let mut peripherals = stm32f429::Peripherals::take().unwrap();

    //Enable gpio b clock
    let rcc = &peripherals.RCC;
    rcc.ahb1enr.write(|w| w.gpioben().bit(true));

    //set pin 14 to output
    let gpio = &peripherals.GPIOB;
    gpio.moder.write(|w| w.moder14().bits(1));

    //Turn on led
    gpio.odr.write(|w| w.odr14().set_bit());

    loop {

        delay(10000);
        if  gpio.odr.read().odr14().bit()
        {
            gpio.odr.write(|w| w.odr14().clear_bit());
        }
        else {
            gpio.odr.write(|w| w.odr14().set_bit());
        }
        
    }
}

fn delay(count: u32) {
     for _ in 0..count { cortex_m::asm::nop() }
}

Although Rust is an exciting new option for embedded development, it will take some time for it to supplant C/C++ as the standard. A lack of official support from major silicon vendors like ST, NXP, and Silicon Labs means that adding support for new microcontrollers can be a tedious process. Additionally, C/C++ frameworks like ARM’s mbed offer large, general purpose libraries and drivers that can be used across a variety of ARM targets with little to no modification.

Learn more about DMC’s Embedded Product Development Services and Embedded Systems Platforms expertise.

The post Oxidizing Bare Metal: Rust Programming for ARM Microcontrollers appeared first on DMC, Inc..

Typically, these projects are done in a staged approach where an initial prototype is designed and built. This prototype can then be used to secure funding for additional stages of design, as well as ensure the product meets all of the requirements.

For this type of rapid design and prototyping, we often utilize the Arduino platform.

What’s Up With Arduino?

Arduino’s come in a variety of configurations targeted at various Performance, IO, and Communication Requirements, so there is usually a model that has already been tried and tested that would work for your specific application. Arduino also provides a free IDE and C style programming language that allows you to start running custom code within a matter of minutes.

However, once your program starts to stretch beyond a few hundred lines of code, or across more than a handful of files, the IDE can start to become cumbersome and difficult to work with, especially if you’re used to more advanced IDE’s or text editors. After dealing with the annoyances of the Arduino IDE for years, I’ve finally upgraded to a more user-friendly option: Visual Studio Code.

What is VSCode?

Visual Studio Code, or VSCode, is an open source, lightweight, extensible text editor, that is designed and supported by Microsoft, and runs on Linux and Mac in addition to Windows. The extensibility allows you to write extensions to customize VSCode to best suit your needs, and programming language.

With a broad user base, there are a lot of free extensions already available, including an extension to support Arduino programming without ever leaving the VSCode editor. VSCode is designed to handle multiple folders and files within the editor and utilized Microsoft’s IntelliSense auto-completion tool to help speed up your programming and reduce typos.

Using VSCode for Arduino Projects

To start using VSCode for your Arduino projects, follow the steps below.

Step 1 – Download and Install Drivers

VSCode uses the drivers that are installed with the Arduino IDE, so we need to download and install that first.

1. Download the IDE for your OS from https://www.arduino.cc/en/Main/Software.
   
   
    
2. After the download is complete, run the installer, leaving all the default selections and options.
   
   
    
3. Be sure to install the COM port and USB drivers if prompted.
   
   

Step 2 – Download VSCode

1. While the Arduino IDE is installing, download VSCode from https://code.visualstudio.com/Download.
    
2. After the download is complete, run the installer.
   
   

Next Steps

I recommend the following configuration for the additional tasks during the install.

1. Once installed, Launch VSCode.
    
2. Click the Extensions button on the left side of the editor, (or Ctrl+Shift+X) to display the extension marketplace.
   
   
    
3. Type Arduino in the search bar, to filter the extensions to only those related to the Arduino platform.
    
4. There are a few extensions available for Arduino, but I prefer the one supported by Microsoft.
    
5. Click the Install button and when prompted allow installation of dependencies.
    
6. Click the Reload button to relaunch VSCode with the Arduino extension enabled.
   
   
    
7. Depending on your firewall settings, you may be prompted to give VSCode firewall access.
   
   

Programming in VSCode

One more Reload and now, we’re set to start programming. To make sure everything is installed properly, we’ll start by opening up the example Blinky.

Open VSCode’s Command Palette with Ctrl+Shift+P. Once the command palette is open, you can start typing to filter all the options or to search for useful commands.

1. Open the Command Palette and type Arduino, and select Arduino:Examples in the results list.
   
   

2. In the new pane to the right, select Built-in Examples>>01.Basics>>Blink. By default, this will open a new VSCode window, with the Blink sketch and a Blink.txt help file listed in the explorer pane on the left.
    
3. Select Blink.ino from the explorer pane to open the sketch in the editor.
    
4. Connect your Arduino board to your computer, and then, in the bottom bar of VSCode, you can specify the COM port for your Arduino and the board type.
   
   
    
5. Clicking COM opens a small selection window at the top of VSCode that should display your connected Arduino.
   
   
    
6. Clicking <Select Board Type> opens a new pane on the right where you can select the board type. If various configurations are available for your board, then you need to specify those as well. I’m using the Arduino Mega with the ATMega-2560.
   
   
    
7. Open the Command Palette again (Ctrl+Shift+P) and type Arduino:Upload (Ctrl+Alt+U) to upload the Blink sketch to your Arduino. You should see LED13 start blinking about once per second.

Now you’re all set to start writing new Arduino sketches in VSCode and enjoy the features of a more advanced text editor. Learn more about DMC’s Embedded Development and Embedded Programming or Contact Us to get started on a project today.

The post Arduino Programming with VSCode appeared first on DMC, Inc..

Our engineers created this overview of the product development process to demystify how to bring your product to market. 

Learn more about DMC's Custom Software and Hardware Development services.

The post The Product Development Process: How to Bring Your Product to Market appeared first on DMC, Inc..

I was eager to try it out, but unfortunately I don’t have a home phone line anymore. I hooked it up to my Voice Over IP (VoIP) adapter that I haven’t used in years. It almost worked! Well, it rang like it is supposed to – waking up dogs and babies in a two block radius. I could even have a pleasant conversation over it, but I couldn’t dial out. I heard a dial tone, but it ignored the number I was trying to dial.

The problem actually was not the phone – there is nothing could go wrong with it, ever. It’s probably bullet-proof and could easily survive a minor nuclear apocalypse (haven’t tried it, it is in my to-do list). The problem was in my Voice Over IP adapter. It’s not compatible with “ancient” rotary-dial phones, and is designed to work only with (well, also vintage) push-button phones.

Ironically, rotary dial (or pulse-dial) is actually digital protocol, and is supposed to be closer relative to VoIP than “modern” push-buttons phones. The later ones use analog encoding to transmit digits. This process has a fancy name: Dual-Tone Multi-Frequency Signaling (DTMF).

The rotary dial is pure digital – transmitting numbers as a sequence of on/off pulses. One pulse corresponds to digit “1”, two pulses – digit “2”, etc; Ten pulses represent digit “0”.

Of course I could get another VoIP adapter that supports pulse dialing, but this would be too easy. Instead, I decided to make my own pulse-to-DTMF converter.

I had a few microcontrollers lying around and decided using them to generate DTMF signals should be trivial. Obviously, it’s been done before and I found an Atmel application note to do exactly that. There is nothing special there, just using a PWM (the same method I used to play audio on the TI Launchpad) to generate an analog signal. The only difference is that I am not using any external memory here. DTMF consists of just two sinusoidal waves, so we have to store one period of the sin wave and it is small enough to easily fit to the microcontroller’s internal memory.

As I mentioned before, reading pulses from the phone is very simple. It’s already digital, just count them up – and bam you get your digit. Here is a test setup with my adapter still on the breadboard

From left to right:

• Wi-Fi to Ethernet converter. Just because my VoIP adapter doesn’t have a Wi-Fi and I don’t like having Ethernet cables everywhere
• VoIP adapter. I had the old Cisco/Linksys PAP2
• Phone (kinda obvious)
• Breadboard. Schematic below:

The phone line voltage is in the “on-hook” state. Confusing term? It seems to have originated because you are supposed to keep the earpiece on the hook and “off-hook” it in order to answer the call.

Back to the voltage. So the “on-hook” voltage is quite high, around 48V DC and even higher (around 90V AC) during the ring. I decided to connect my board after the phone switch, so I am getting the power only when the phone is in the “off-hook” state (meaning the handset is not on the phone).

In the “off-hook” state, line voltage is supposed to drop down to around 5V DC, which is perfect for my AVR, but I still added a 5.1V zener diode D1 just in case.

The rotary dial module is disconnected from the phone circuit and connected to my adapter only. The purpose of the connection between pins F and RR is to make phone think that the dial is still connected.

I am generating DTMF/PWM signal on the AVR pin 5 and feeding it to the emitter follower Q1 via the low-pass filter (C1, R3).

If you are curious, you can grab an AVR source code here.

Here is the video testing the adapter

During the test I ran into the interesting issue. I noticed that AVR power consumption at the power-down mode is much higher than I anticipated (~500uA instead of ~10uA). After poking around I traced the issue to the debugWIRE interface. I was using debugWIRE to download and debug code on the AVR. Yet apparently debugWIRE draws a lot of current (~500uA). Disabling debugWIRE via fuses and using ISP instead solved the problem.

The last steps were to wire the adapter on the perforated board.

Then mount it inside the phone (thank you again, hot glue)

Done! Just put the cover on. Obviously it looks exactly the same as before modifications.

Next steps. I guess there is none. Well, maybe to record how this phone rings and use it as a ringtone.

Contact us to get started on your next Embedded Development & Programming project. 

The post Updating Your Rotary Dial Phone for the Digital Age appeared first on DMC, Inc..