Forum - Recent Threads

Winners Announcement – Start A Movement Design Challenge

JoRatcliffe — Mon, 20 Jan 2025 10:30:12 GMT

Hi everyone, I hope you all had a great weekend.

Now, after months of planning, creating and making, it is time to announce our winners and recipients of the official Finisher prize. 🎉

But first, a short reminder of the challenge, the kit and the prizes we are awarding.

The Start A Movement Design Challenge was all about creating a project that incorporates automated movement or kineticism of some kind using the official kit with Challengers receiving an Analog Devices TMC5272-EVAL-KIT, a QSH4218 NEMA 17 stepper motor and PSU.

The Kit

The Sponsored Kit
	TMC5272-EVAL-KIT 2x 2-phase stepper motor up to 0.8 A (RMS) coil current (1.12 A (PEAK)), Supply Voltage 2.1 to 20 V DC, SPI and Single Wire UART, Encoder Interface with alt. functions, 1 to 256 microsteps Buy Now
	TRINAMIC / ANALOG DEVICES QSH4218-35-10-027 Stepper Motor, Single Shaft, Hybrid, 42 mm, Bipolar, 1.8 °, 27 N-cm, 1 A Buy Now
	MULTICOMP PRO MP001982 AC/DC Power Supply Level VI, ITE, 1 Output, 12 W, 12 VDC, 1 A Buy Now

The Prizes

Prizes are subject to change but will be of similar price and style.

Prize

Prize Category

Grand Prize Winner

Approximate Value $1,047 USD*

KELKART 27.5 Inch Electric Bike, Pedal Assist City E Bike with 48V 10.4AH Battery

Runner Up

Approximate Value $1,047 USD*

Fafrees Electric Bike, 20" Folding Electric Bikes for Adults, 36V 16Ah/576Wh Removable Battery Ebike 90KM Mileage Pedal Assist

Finisher Prize**

To be a finisher you must complete 5 forum posts and a project article post and show us testing the resilience of their project.

Approximate Value $30 USD*

MultiComp Pro Multimeter Set

*Or local equivalent
**Grand Prize and Runner Up winners will also earn the finisher prize.

Winners

Now the moment you have all been waiting for. We had several projects of an extremely high caliber all competing for the top spots, making it very difficult to pick the winner of the grand prize. The final decision was extremely close, and here it is...

Grand Prize Winner

taifur’s Accessible Sewing Machine

taifur , your build was extremely well executed, well documented. What you have created is highly practical and genuinely helpful for someone with specific needs. Having used sewing machines myself, I know how sensitive the foot pedal can be so you have done a great job of enabling someone to control it precisely using the flex sensor. Really great job!

Runner Up

dougw’s Demanding Stepper Motor Applications (Connector Tester and Thread Tapping Machine)

dougw , your project was also incredibly well documented and both aspects of the build, the connector tester and the thread tapping machine itself, were really impressive. The use of a second stepper motor and the way you have synchronized them so they work together is amazing and really gets to the core of what this Design Challenge was about. Your demonstration video really highlighted the elegance and precision of what you have made.

Next up, please join us in congratulating everyone who was judged as qualifying for the official Finishers prize.

Our Official Finishers

Gough Lui - Automatic Voltage Regulator (AVR) by Stepper-Control of a Variac

This was a superbly done project, executed fantastically amidst challenges. It is a great use of the Variac which you already had with a nicely made ‘hat’ for the stepper motor on top. The thermal imagery and videos demonstrate all the work you have done really well.

fyaocn - RangeDetect Rover

A really nicely put together project with lots of images, a flowchart, and short animated clips which brought it to life. The end product was a great-looking rover which I can almost imagine roaming the surface of Mars.

amgalbu - Octoscope

Mounting a wireless camera on a ring around a 3D printer was a really interesting premise for a project right from the start and it was fantastic seeing this come to life. I am already picturing this creating lots of great footage of 3D printing in action.

rsc - Satellite Tracking Ham Radio Antenna Rotator

This project was a very cool continuation of work on other antenna rotor control systems and similar projects. Plus, your forum posts were really rich in content and no doubt helped other Challengers.

Well done again to all of our prize-winners, I know you will all congratulate them on a job well done. Plus, a big thank you to all of our Challengers and our judges! 🙂

The Wrap-Up – Start A Movement Design Challenge

JoRatcliffe — Fri, 17 Jan 2025 16:45:36 GMT

Hi everyone, I hope you have had a good week. I will be announcing our Design Challenge winners on Monday but ahead of that I wanted to share a wrap-up of everyone’s hard work over the past weeks and months.

Firstly, congratulations again to everyone who took part in the Start A Movement Design Challenge. It has been amazing to see initial ideas turn into fully-functioning projects. Everyone has really pushed to make the most of the kit, overcome different challenges, bring their plans to life, and support their fellow Challengers.

So, let’s just take a moment to appreciate all the work that everyone has put in. I’ve written a short summary of each project in the group and linked over to the full project or the latest update whenever I can. Just in case if you haven’t already, I highly recommend checking out each of these in full :) In no particular order, let’s kick off with…

Rsc – Satellite Tracking Ham Radio Antenna Rotator

Rsc has worked on several different antenna rotor control systems for ham radio and used the kit from this challenge to make a mini antenna rotor that interfaces with satellite tracking software and automatically points a direction antenna at a chosen satellite. Take a look!

RParkerE – Pick N Place Machine

RParkerE wanted to build an affordable, small scale, pick and place machine that has a customizable frame which could be taken by hobbyists to build and use themselves. An Nvidia Jetson Nana connected to a Pi Camera will enable object recognition and detection as well as ensuring parts are properly aligned. They have the motor controls and vision system working and hope to soon integrate these together and start testing.

dougw – Connector Tester and Thread Tapping Machines

Dougw first created a connector and cable tester system that can perform cycle testing on connectors to determine their wear characteristics by mechanically connecting and disconnecting connectors repeatedly and accurately until failures start to occur. Then, a thread tapping machine was created to save time and tedious thread tapping activity when 3D printing. The builds required using two, precisely synchronized stepper motors so that the tap screws into a hole without applying any axial force to the threads. Very cool and well worth watching the video demonstrating this taking place!

taifur – Accessible Sewing Machine

This is an assistive tech project to enable someone who cannot use a sewing machine with a standard foot pedal to instead control it using one of their hands. Instead, a flex sensor fitted to a finger with 3D-printed rings controls the stepper motor which turns and presses a wedge onto the pedal - speeding up, slowing down or stopping the sewing machine as needed. Have a watch of the demo video if you haven’t already, it is great seeing it all in action.

fyaocn – RangeDetect Rover

The rover is capable of avoiding obstacles and changing direction to find a path forwards to make its way from one place to another. Very cool project and the sensors on the front really give it that ‘Mars Rover’ look.

crisdeodates – Automated Star Tracker

Speaking of other planets, crisdeodates looked to the skies and used the kit to build an automated star-tracking module, consisting of a pan-and-tilt system that can accurately focus a telescope to the right azimuth and elevation of a known heavenly body. I’ve been informed a project post will be coming soon including more detail on their build.

Gough Lui – Automatic Voltage Regulator (AVR) by Stepper-Control of a Variac

Using the kit, Gough Lui made an Automatic Voltage Regulator (AVR) by creating a computer-controlled adaptation of an old Yamabishi electric Variac, attaching the stepper motor on top via a 3D-printed ‘hat’. A fantastic project which was achieved in spite of challenges and includes really neat videos and thermal imagery for you. If you haven’t already, definitely make sure you check this out.

amgalbu – Octoscope

For this project, amgalbu mounted a wireless camera on a slip ring driven by the stepper motor and controlled by the TMC5272 controller, over and around a 3D printer. The integrated camera provides a 360-degrees view of objects as they are being printed. Take a look at the full project post for plenty of references and links on how they accomplished this :)

pandoramc – Metallurgical Image Acquisition Stage Design

Pandoramc created a mobile stage for XY movements in a metallurgical microscope for capturing high-quality images. It consists of a one axis stage controlled by the TMCL-IDE for displacement and the camera software for acquisition. Check out the full project post for images galore, videos and to see how they incorporated a second stepper motor.

sunnyiut – MicroDose-Efficient Syringe Pump for Controlled Fluid Delivery

Infusion pumps are critical for administering precise amounts of medication or fluids but purchasing them can be cost-prohibitive for rural and low-resource healthcare settings. Sunnyiut aimed to create a low-cost, simplified, easy-to-use version of a syringe pump.

meera_hussien – Smart Conveyor Belt for Sorting System
meera_hussien began working on a small-scale, modular replica of an industrial conveyor belt system, using IR sensors to detect objects on the conveyor and diverting them into designated bins with servos.

vpvypham1994 – VitalTrack: Adaptive Radar-Based Health Monitoring System

Vpvypham1994 started developing a compact radar system for vital sign tracking, utilizing the TMC5272 motor control technology to ensure precise radar movement for continuous and uninterrupted measurements, using a 9V battery for enhanced portability.

mariodl99

mariodl99 developed a 3D-printed exoskeleton assisted device for individuals, inspired by other exoskeletons that rely on myoelectric sensors. Be sure to check out the videos included in this project summary!

So there we are! I’ve done my best to provide a wrap-up of as many projects as possible but I’m conscious that some folks are still working on theirs which is amazing. If I have missed the latest update on your work, DM me and I’ll be happy to update this post :)

A big congratulations again to all of our Challengers. It won’t be long until the announcement of our prize-winners. Have a great weekend!

Don't forget to get your final updates in before the deadline! (and Happy New Year!)

JoRatcliffe — Mon, 06 Jan 2025 11:41:45 GMT

Happy new year, everyone!

Projects are due at the end of the day today, 6th January, so don't forget to get your final updates in 😀

As my colleague cstanton said in a previous thread here, when you are doing your final write-ups you are completely free to message me and clarify what you have posted and where, if needed.

AVR Part 5 – Connecting Variac and Stepper

Gough Lui — Sun, 05 Jan 2025 13:01:18 GMT

In this chapter, I’ll be looking at my last-ditch attempt to progress my “Make a Movement” design challenge in spite of my medical conditions. As I cannot walk, I’ve had to literally crawl around to make this happen. After all, the finish line is getting closer by the day.

The Variac

The unit in question is an old Yamabishi Electric Variac from Japan. This was a purchase from a ham-fest many years back, so it’s nothing particularly modern, so safety isn’t exactly high on the list of features.

Nevertheless, after removing the grub screw and removing the knob, I found the centre shaft to be 8mm in diameter with knurling. The shaft protrudes 18.5mm from the surface of the Variac. There is no flat-section on the shaft, being entirely round. The top surface of the Variac didn’t have any mounting holes, so there is nowhere to directly anchor the stepper motor.

As a result, I decided that I needed to design a “hat” to fit over the top 117mm diameter surface of the unit and hold itself in place with some screws pushing on the metal surface of the casing and using the rectangular surface near the terminals. That way, it would be like a “hat” sitting on top of the Variac.

In order to do this, I drew up a quick design in TinkerCAD to accommodate this, but also to adapt this “hat” up to a new mounting surface which would be just the right height to keep the stepper and Variac shafts centred and not quite touching one-another.

Stepper Motor

The stepper motor is a NEMA17 style motor. As a result, it has a square form factor with M3 mounting holes spaced 31mm apart. They appear to be tapped to a depth about 4-5mm. The motor body itself measures 42mm and is 33.5mm deep. The shaft measured 5mm diameter with a D-cut profile with 20mm of height. The shaft raises 24mm from the body of the motor, including the 2mm raised portion of 22mm diameter.

To adapt this, I have a flat, round plate of 3mm thickness with the mounting holes for the NEMA17 style motor and a barrier surrounding the motor itself to add additional strength. I felt this was necessary to ensure that any over-stress doesn’t destroy the adapter.

Coupling

Coupling two round shafts together is a bit of complex business, as they might not be perfectly aligned in the centre. Nevertheless, not having any access to mechanical hardware like belts and pulleys or spider couplings, I decided simply to 3D print a “tube” with the provision for screws to add additional clamping force. It’s not high-tech and it won’t work for high torque, but perhaps that’s a “feature” and not a bug, in case of any unexpected accidents.

3D Printing and Fitting

After designing it, I decided to employ my 3D printer to manufacture these parts and see if it would work. My printer is a bit old and the belts are a bit sloppy, given the short time remaining, I’ve pushed the speed to the absolute maximum.

The “Variac hat” was supposed to be a tight fit, but this was too tight. After tapping it a few times with a hammer, it split along the side. It’s still tight on the unit, although this does mean that there might be a bit of off-axis alignment when fitting the stepper.

The stepper plate and coupler were printed as a second job due to bed space limitations.

The motor fits well within the plate.

The coupling needed to be cleaned out with a drill bit to get to the right diameter. Unfortunately, once the coupling had both shafts inserted, it was evident that the two axes were not quite aligned, resulting in difficulties getting the top plate installed.

As a result, just two screws were used to secure the top plate to the hat, alongside some reaming of the screw holes to provide a bit more adjustment room. The coupling was unfortunately not very tight on the Variac side, leading to the potential for slip. Using plastic and having machine screws cut threads into it doesn’t result in much strength. This might protect the Variac from over-torque damage, but it does mean that step-to-ratio correspondence may not be maintained. The design also doesn't have a defined way to detect the end stops (e.g. by limit switches) and would instead have to either naively bump into an end stop repeatedly to guarantee a position or use StallGuard.

Attempting to run the board today, it seemed that the Landungsbrucke didn’t detect the driver. Even pressing scan didn’t work, but manually selecting it seemed to restore it to operation.

Not sure what went wrong – it was automatically detected previously. Perhaps I have a bad/broken connection somewhere.

community.element14.com/.../VID_5F00_20250105_5F00_234242042.mp4

Testing with the board shows the motor has sufficient torque to overcome the slightly stiff shaft of the Variac. The coupling does result in some motor resonances being coupled into the wiper brush assembly, which is probably not good for lifetime, but turning on StealthChop seemed to reduce some of them.

Conclusion

Well, it seems I made some rookie mistakes by not accounting for the tolerances in the top of the Variac and the 3D printer, resulting in an adapter that was just too tight, resulting in it cracking as soon as it was fitted. This could be remedied with a slight adjustment to the 3D model and a re-print. The slightly off-center part of the spindle on the Variac was not expected, but made the top plate mounting difficult. Testing seemed to show the motor to be capable enough of driving the wiper, but there is a potential for slipping with the current plastic coupling and the potential for resonances to be coupled into the wiper which might accelerate its wear.

Unfortunately, I hadn’t had any time to work on the integration of the driver control with a third-party microcontroller platform. I’m intending to use the Wiznet W5500-EVB-Pico based on the RP2040 as I’ve used with other creations, but the software will need to be ported, driver connected and tested. This time, I’m really out of time … so this will be the end of the series. At least, I’m somewhat closer to my goal, even if I did not reach it in the end.

RangeDetect Rover 5# Coding for the Rover

fyaocn — Sat, 04 Jan 2025 10:57:23 GMT

5# Coding for the Rover

1 Function Description
2 The Hardware Interfaces
3 Software
4 How to improve it

1 Function Description

The range detect rover is build with interactive of multiple sensors to sensing the environment. Then control the rover move around in complex situation like office, home with some edge intelligence.

The sensors include ultrasonic sensor with slow and short detecting distance around 20cm, and one expensive 60GHz radar sensor with precise range detect of 200cm, then sensor module even with intelligence to detect human presence or sudden movement. This helps move around with human interactive.

2 The Hardware Interfaces

Here is hardware interfaces and how the MKR board, TMC5272 board, stepper motors, range detect sensors and Power supply connected.

Each connection has been tested in previous forum post, it proves to be reliable in functional.

3 Software

This is how the software flowchart runs,

After configurating the hard ware interface one by one, the program is running in two different loops. One is for sensor value scan and fusion the data to decide the movement to the rover. To keep going or dodging in other direction.

Another is for stepper motor state machine, report the state of the rove and control the rove with instruction to left or right wheels in velocity mode.

4 How to improve it

This is simple range detect sensor fusion project. If the sensor is arranged in one rotary pole, the surrounding distance can be mapped more precisely, like lazer radar in automatice car does. That would be potential improvement for this projec.

This Project is design with Arduino. I have tried with arduino cloud editor https://app.arduino.cc/sketches

That is also one alternative design platform for arduino. That is Another interesting work to do next.

AVR Part 4 - TMCL-IDE Setup and First Movements

Gough Lui — Sat, 04 Jan 2025 05:57:33 GMT

It's time to get the TMC5272 plugged in and running, so let's see how the TMCL-IDE works and just what it can do.

Installation and Setup

I'm running on Windows, so I downloaded the latest version of TMCL-IDE from ADI Trinamic's website here. At this time, it is V4.5, but at the commencement of the challenge it was V4.4, so it seems it gets regular updates.

Installation is a case of following the wizard. Afterward, the software is installed - the default directory is "C:\Analog Devices\TMCL-IDE-Rel4.5.0\V4.5.0"

Plugging in the USB-C connection, the Landungsbrucke is automatically installed and comes up as a USB-COM port with the above VID 2A3C (Trinamic Motion Control GmbH & Co KG) PID 0700 (Evaluation Device) pair.

Starting the software tells us the firmware on the Landungsbrucke is out-of-date and to download new firmware from here. Make sure you download the corresponding version of file - in my case, the V3 file.

Then, the board can be flashed using the firmware update tool. It takes a minute or two and then the board automatically resets.

If you start with the power supply off, as suggested by the manual, the system will detect the board and the driver board then complain there isn't any motor supply. Turn the power supply on and voila - it's all ready to go. The IDE seems to default to automatically enabling the drivers, hence the warning to not unplug or plug motors to the kit when it is on, as it can cause damage.

Looking at the guide, it seems that setting the current was the next step. Choosing the reference resistor to be 10k is the best option to enable the maximum current of 0.8A RMS, as the motor itself is rated for 1A. However, when I did this and hit the "Calibrate settings automatically" button, it complained that it can't reach the full current and the resulting motor movements seemed to have low torque. I suspected it wasn't running the right current, but reducing this to 0.75A seems to change the button to green and no warnings appeared. So it would seem that the chip might not be able to run at the full rating in the way it is configured, but this may be the closest we can get.

The IDE has a lot of useful, albeit, sometimes intimidating features. For example, the advanced configuration for the current gives a few more options, while the box to send raw commands gives a lot of freedom but doesn't give a lot of guidance.

The register table is amazing though - lots of information here and the possibility to monitor the values as well. This really is a lot easier to work with than the datasheet alone.

Chopper settings allows for changing the StealthChop feature on or off. This has the effect of mitigating some of the classic stepper noises from the motor by controlling the driving waveform and frequency. I'm not quite sure how to set the appropriate threshold settings, and as a result, I do get some strange positioning undershoots when turning it on. Perhaps it's my incorrect settings that are causing the motor to miss steps.

The Sine settings dialogue allows you to tweak the driver's waveforms. There is also an automatic tuning feature that tunes the phase offset between windings for better StallGuard performance.

As far as I can tell, StallGuard is a feature for sensorless detection of an impending motor stall, potentially avoiding step-loss and allowing for sensorless stepper applications. It seems that this dialogue is used for testing the stall-guard values that need to be set under application load to determine when a stall should be detected. While a simple idea, getting this to work reliably in practice is a bit of a challenge. I tried stalling the motor manually, causing step-loss, but depending on the situation, sometimes it would show something while other times it did not. It seems it's not a system that works well at very high or very low speeds for "hard" stops based on FluidNC's Wiki, and a few steps lost appears to be not-unusual.

Movements

Time to get it moving. Two of the main modes are Velocity Mode and Position Mode. Velocity mode is as it sounds - it controls the speed of the rotation and the acceleration used to get there.

The system allows you to configure the relevant speed and acceleration values, with a graph showing the actual values the driver is generating. Using the motion calculator also allows you to translate the stepper-motor driver units into something more "human".

The second mode is the position mode, which is perhaps the more useful mode for some applications which rely on the stepper's behaviour to move a precise number of steps (or microsteps).

In this case, I was able to program in a "wave" where the stepper turns in one direction a full rotation, then back in the other, with smooth acceleration/deceleration such that the motor's position is changing nearly perfectly sinusoidally.

Here's a quick video of this happening:

community.element14.com/.../tmcvideo.mp4

Does It Get Hot?

Surprisingly, no. Not really. Then again, it's not driving a heavy load - just its own inertia and a tiny bit of electrical tape, back and forth.

The Landungsbrucke is hotter than the driver board!

The driver chip up-close isn't particularly hot either.

Turns out, the motor is the hottest part of it all!

Integration

From here, to use the driver in a practical application, there seems to be two ways forward.

One potential way is to use the Landungsbrucke since there is a full TMC-EvalSystem firmware sources available and the bootloader nature of the firmware also means that no special programmer is necessary - TMCL-IDE is all you need. To actually get developing will require Eclipse IDE and GCC toolchain to be set-up, and I suppose it would take some effort to understand the code that already exists, much of it going to support other boards that are not the one we are using. As I'm not particularly familiar with the Gigadevices MCU and the HAL functions, I decided that this probably isn't my preferred path, but it is an interesting one as it truly makes it an evaluation platform, rather than just a simple piece of demonstration kit.

The other way would be to talk to the TMC5272 directly over its SPI or 1-Wire UART interfaces. Thankfully, rather than starting from scratch, ADI Trinamic have a TMC-API which provides a C-based vendor-agnostic code that can be glued into your platform of choice by writing the necessary call-back functions to provide higher-level control of their stepper drivers. This is like having an Arduino library at hand, just that you need to "teach" the code how to access the hardware of your platform. That's a nice compromise. As for hardware connectivity, it seems SPI would be relatively straightforward, however, for a large number of motors, 1-wire UART would be more efficient as it supports multiple drivers on the same line. It's a strange hybrid between I2C's open-collector bus and regular UART, allowing it to be "shared". But because of this, there are some considerations, especially that all TX lines should go high-Z when done, so that may introduce some timing constraints. Perhaps it'll be SPI for me.

Finally, this has me thinking about just how to implement this for my Variac. The Variac has hard stops at each end and StallGuard might be usable to detect the end-stops as the spinning resistance of the wiper and the hard stop should be sufficiently different and no harm will happen if the torque is limited by a reduced drive current (and hopefully, any mounting hardware will be durable to the torque too). But having read that it's not good at low speeds has me slightly worried. What if the motor is already at a limit and is trying to find the limit - will it work? Or will it be reliable? I presume this means, after every power loss, the system will have to sweep the Variac's full range, which wouldn't be nice to any connected load and also adds wear to the carbon brush.

Another thing is whether I drive it in position or velocity mode. I think my application is better suited to position mode, as there's about 270 degrees of travel at the most. But this is where things get complicated, as amount of turn for a given voltage increase or decrease depends on the input voltage on a Variac, which is the quantity that is varying and not being directly measured. So perhaps this means I have to either take a naive approach and do fixed steps up or down and repeat until the result is in the desired range (in which case, it feels like I'm going the quick-way-out and it's almost like using a step/direction input and thus losing all the smarts). Or I will need to compute, based on the step number, the transformer's ratio at the time a voltage reading is taken, then back-calculate what the input voltage would be, then calculate the target ratio that would give the desired voltage, then compute what step number that would be, then drive to that location. I think this is a more sensible approach, but it depends on the ratio computations being very accurate (and thus, perhaps a fine-tuning loop might be necessary too). Having the ability to adjust a dead-band to avoid needless moves is also important, as I won't want to "burn out" the carbon brush with too many needless moves.

Another issue simply is that the Tektronix PA1000 Power Analyser only gives a voltage reading twice-a-second. This means that the opportunity for compensations will be limited, so we want to make the best compensation we can at each step. Unless I build my own mains-waveform-sampling input, which could theoretically go down to "per-cycle" levels of feedback, but that is a potential danger.

Finally, I would still need to design a chassis to hold the motor and a coupling to somehow connect the two round-ish shafts together. While 3D printing is likely going to be the only means I have for this, whether the material will be strong enough to withstand repeated StallGuard trips to find the rotation limits, whether I can even get the right size/shape to fit as the Variac isn't designed for any mounting on the top surface, are all going to be challenges. Perhaps I have bitten off more than I could chew ...

Conclusion

In this part, I've managed to get the three boards running with TMCL-IDE. The TMCL-IDE package is rather useful in testing and demonstrating the capabilities of the stepper motor driver and as a reference for what register values are set for a given mode of operation. As a true novice in this area, there are many settings I don't fully understand, but despite the stumbling in the dark, at least I got some motion out of it and resolved initial difficulties with connection and low torque. That being said, I still exceed the limits from time to time, purely by accident.

Integration of the driver is eased by the libraries provided by ADI Trinamic, but also, can include the use of their Landungsbrucke board as they have an Eclipse/GCC build environment and the board has a bootloader that allows for flashing without the use of any dedicated programmers. The downside would be needing to setup such an environment and familiarise myself with the existing code for the Gigadevices MCU on the board, plus learn about its HAL functions. Otherwise, use of their libraries by coding out the "glue" portion is a possibility, thereby working with Arduino or something more user-friendly. However, this is working at a lower level and will require connectivity by SPI or 1-wire UART (which is convenient for running many stepper drivers, but is a bit like an open-collector bus like I2C, just using UART).

Will I get to the end? I doubt it given the time remaining and my current state of health. Aside from the complexities of learning to drive the stepper driver on another platform, to realise the project will also need mechanical design to couple the motor to the Variac and right now, I can't even walk to the 3D printer ... or to where my Variac is stored. Unfortunately, my participation in the design challenge seems to be nearing its end ...

ASM - Working more with the Sensor

taifur — Fri, 03 Jan 2025 12:10:20 GMT

In my project, I am using a flex sensor for detecting the bending of the finger to control the foot pedal. A flex sensor is a variable resistor and we need to convert the resistor value to a proportional voltage output to read it using a microcontroller. We usually make a voltage divider circuit to get proportional voltage from the sensor. In one of my previous writings, I calculated the value of the series resistor to get maximum sensitivity from the flex sensor. The value was around 42K and I connected one 20K and one 22K resistors in series to get 42K resistance. The sensor connection is shown in the image below.

Without using any external PCB I directly soldered the resistors and flex sensor's terminal to the Arduino board as shown in the image above.

I added a long flexible wire to the flex sensor so that it can be bent from a distance. The flex sensor will be worn on a finger and the sensor should be easily bent and straight without any issue. To make the process stable and comfortable I designed two 3D printed rings with small holes for the sensor. The bigger ring will be worn first and the sensor's lead side is tightly attached to the ring using two screws.

The wearing process of the sensor is shown in the following images. The sensor can move easily inside the top ring but it can not get out from the ring.

The video in action:

community.element14.com/.../Wearing-the-Flex.mp4

All the 3D design files are attached below.

community.element14.com/.../ring_2D00_big.stl community.element14.com/.../ring_2D00_small.stl

AVR Part 3 - Connections and Power

Gough Lui — Fri, 03 Jan 2025 11:22:25 GMT

Hello and welcome back. In this section, I get the connections ready and take a slight unexpected detour from the project.

Connecting the Motor

In the last section, I unboxed the motor which had four wire connections. This was a little new to me, as I used to recall steppers having six wires. This is because this is a bipolar stepper, as opposed to a unipolar stepper that has centre taps on each winding. For a better explanation of the differences, this page seems to be a good reference. But I suppose what it means in practice is that the driver needs to drive both coils both positive and negative, thus two H-bridges are needed at a minimum for the two windings. Thankfully, we don't have to build them discretely.

The connections on the PCB are marked OA1, OA2, OB1 and OB2. I can only surmise this to mean A phase and B phase connections 1 and 2. I don't have any real experience with these motors, but I suppose the distinction is somewhat arbitrary as to which phase is A phase and B phase, as long as the coil directions are correct. The motor itself, according to the datasheet has A+ as Black, A- as Green, B+ as Red and B- as Blue. Allocating A-phase to A and 1 as +ve, with 2 as -ve, this gives the following connection order:

Power Supply

As mentioned in the previous post, the connector on the power supply is not suitable for this kit, so it would have to be cut-off. Then, we had the interesting dilemma - what is the polarity of the wires? A quick check with the DMM appears to confirm that the supply has the striped lead as negative.

As a result, with the plug turned upside down so the lead markings are visible, I believe this to be the correct connection for the board.

I was curious as to how efficient the supply was and whether over-current protection was working. I've had some no-name power supplies blow their transistors violently when their outputs were accidentally shorted (quite a loud bang in my younger years, followed by a nice acrid-smelling smoke that I still haven't forgotten), leading to my slight reservation about using an unknown plugpack for experimentation.

The output voltage graph shows the output to be pretty decently regulated for a non-precision supply. Some power-saving mode must be present below about 100mA resulting in the downward slope of voltage initially. The adapter cut-out at about 1.34A, so a healthy margin from the 1A rating, but not too much to cause damage. The adapter was quite cool, at least on the outside, but then with just a 12W rating it isn't really dissipating all that much power given its efficiency level VI marking.

But just to be sure, I also checked the efficiency in the same test, by having my Tektronix PA1000 Power Analyser monitoring it while it was being load tested. This is based on a 230V / 50Hz (1%) input.

Of course, efficiency will be low at very low loads, but we can see the efficiency is 80%+ for 100mA or greater loads. Zooming in and doing some math ...

Efficiency mark VI requires an average efficiency of 83% for a 12W normal voltage adapter. By taking the average of all efficiency values between zero and 1A (nominal load), the computed average efficiency is 83.26%, slightly above the required 83% which manes this gets a pass. One also has to consider the fact I'm not an accredited test lab, not controlling for temperature/humidity or calibrating my equipment regularly, so this is an excellent result nonetheless.

Standby power is required to be below 100mW and according to PWRVIEW, it measured 62.923mW so that's also a pass. Nothing to complain about here! Of course, there are other tests I could run, such as ripple and noise, or insulation resistance testing, but I think the above was already diversion enough. On the upside, at least it seems the Multicomp Pro supply is decent in its fresh-state and suitable for running the kit (with its input accommodating 8-20V). How well it lasts in the long run is something that only time can tell.

However, it is probably not the ideal supply for the kit - according to the stepper motor datasheet, the ideal value for a chopper-based driver is somewhere between 4 to 22 x Ucoilnom which is 5.3V for my motor. This suggests a 24V supply may be better (using common voltages). The problem is that the single voltage input for the kit is limited to 20V, so unless you have two supplies, then it's going to be out of range. On the other hand, perhaps 20V isn't quite as hard to get - USB-C PD can supply it, given a >45W supply, but even that is a bit marginal. I guess the only limitation given the power supply is a limitation in motor velocity or torque attainable.

Conclusion

In this part, I've been able to make the necessary connections (correctly, I hope) to enable me to set up the board with a computer. I also took a nice time testing out the included power supply which appears to be all good. The power supply may not be perfectly ideal for the application (the datasheet suggests 4-22x Ucoilnom which is 5.3V) for maximum velocity, but it should still work. Perhaps a 24V power supply would have been a better choice but the single-supply input on the evaluation board is designed only for up to 20V which is not all that common of a voltage. Then again, with USB-C PD, perhaps it's not as uncommon as it once was either ...

The next step is to hook it all up to a computer using a USB-C cable, install TMCL-IDE, update the firmware (if necessary), plug in the motor and power and see whether I can get it to move.

RangeDetect Rover 4# Quick-built Rover Platform

fyaocn — Fri, 03 Jan 2025 03:04:13 GMT

4# Quick-built Rover Platform

1 Select Material for Quick-Build
2 Wheels and shaft coupler
3 Chassis
4 Bodywork and Compartment

1 Select Material for Quick-Build

This rover for this project is for prototype, the material shall be easy to cut and flexible to arrange. Hard wood and stacked carton box are used for the framework to hold the stepper motor and TMC5272 driver board.

2 Wheels and shaft coupler

This is shaft coupler with conveyer belt slot.

The stepper motor shaft with 5mm diameter. The wheel is 2mm with notch. Best shaft reducer is the one hand-cut on hardwook.

This is preassembled shaft coupler and wheel.

To save time, this passive ball-type wheel is used as rear wheel.

3 Chassis

One hard-pressed carton box is idea for chassis, two stepper motors fixed with screws on opposite sides.

The torch by the stepper is enough to drive the wheel without gearbox

4 Bodywork and Compartment

The box is enough to hold all parts with ease.

Then, the rover platform is ready to go.

ASM - Adjusting Torque and Current Rating

taifur — Thu, 02 Jan 2025 19:50:21 GMT

Tuning Current for a Good amount of Torque

After making the linear pressing system with the 3D printed parts and stepper motor I was curious to check it with the foot pedal of the sewing machine. The pedal is not very easy to press and it requires a moderate amount of pressure to operate. It can be comfortably done with the foot but I was a bit afraid of whether my pressing mechanism is capable of moving it down or not. For checking it I placed the foot pedal at the bottom of the armature and started the motor. I was disappointed, it stops when the armature touches the pedal. After thinking for a few moments I got the idea of increasing the supply voltage. I removed the power adapter and connected a power supply to the TMC5272 controller board. I set the voltage to 12V and observed the current and it was only around 60mA while running the motor. I increased the voltage to 20V and this time motor was capable of pressing down the foot pedal as shown in the video below.

community.element14.com/.../Pressing-with-increased-voltage.mp4

Though it worked I was not convinced to do it by increasing the voltage. I wanted to make it workable with 12V. So, I started reading the TM5272 datasheet again to find out whether it has any solution. The article "Setting the Full-Scale Current" on page 54 drew my attention. I got an equation for the RMS and Peak current.

I came to know that by configuring the DRV_CONF register we can set the 100% current or less and the default current setting is not 100%. From the table 14 and 15, I found the required value for the DRV_CONF register for an expected current. I revisited the code and found that the content for four LSB bits is D (1101) which means FSR_Mx bits are 01 and FSR_IREF_Mx bits are 11 which allows a maximum 410mA for the motor. It should work but not!

Possibly the current was not bad for pressing the pedal but it was not working for any reason. I changed the contents of the DRV_CONF register and replaced D with F. F will allow maximum current (800mA) to the motor. I added the marked line in my main code inside the setup function with other configurations to write the value to the DRV_CONF register.

Surprisingly it worked and this time motor was capable of pressing the pedal very easily even from an 8V supply. Current flowing was also increased reasonably.

community.element14.com/.../Pressing-with-12V-and-maximum-current-setting.mp4

Making Connections Fixed

When I started this project I decided to use Landungsbrucke which came with the kit as the main controller of my project. I intended to write custom firmware to read the sensor and control the stepper motor accordingly. The Landungsbrucke board came with preloaded firmware that helps to control the TMC5272 Motor Controller board from TMCL IDE. This is an excellent way for testing and debugging. The most interesting fact is you can monitor and modify all the registers from the IDE. It helped me to clearly understand some of the functionalities of the TMC5272 motor controller. The Landungsbrucke MCU board is based on the GigaDevice Arm Cortex M4 microcontroller and I have no previous experience with GigaDevice MCU. So, I started with Arduino Mega and fortunately, I got a sample Arduino program for the TMC5272 motor controller from Analog Devices official GitHub link. I was able to run the code without any issues and it worked successfully. However, I faced some difficulties while modifying the code and I was able to successfully solve the issues with the help of TMC IDE. After solving the issues I decided to implement the code in GigaDevice Arm Cortex M4 microcontroller. I downloaded the Keil IDE and the required Add-ons for the Keil IDE for GigaDevice. I also downloaded the source code of the pre-loaded firmware. After a few hours of study and experiment, I realized it would be tough for me to implement the GigaDevice MCU within the limited time (I have 6 days only before the deadline). Even I don't have any GD-Link programmers and I am not sure whether ST-Link will work with the GigaDevice MCU or not. So, I changed my mind and decided to use Arduino UNO in my project. I removed all the connections with the Mega and inserted a double-line male pin header into the connector of the TMC5272 and then soldered with the Arduino UNO with jumper wires as shown in the images below.

I made the necessary pin change in my code and uploaded the code to Arduino UNO. It worked as expected.

AVR Part 2 - Unboxing

Gough Lui — Thu, 02 Jan 2025 10:07:25 GMT

This post will mostly concentrate on the parts provided for this design challenge.

Unboxing

It was a fine day, the 22nd of November, when I decided to step outside for a bit and saw a box on my doorstep. All of a sudden, without any notification or warning, my kit had arrived!

Opening it up, I was even greeted by a nice letter reminding me what this bundle was for and it even had a Raspberry Pi GPIO quick-reference keychain:

So I guess PCBs are great not only for rulers and front-panels ... they'll even do as keyrings.

The main stars of the show are the electronics from ADI Trinamic on the left, the power supply (top) and the stepper motor (middle).

The stepper motor looks to be a NEMA-style unit, similar to what you might find on consumer hobby-level 3D printers (at least, visually).

The four wires are coloured red, black, blue and green and emerge from one side of the motor housing. The windings inside are barely visible.

The motor is marked QMot.eu and has a model of QSH4218-35-10-027, which is apparently now an ADI Trinamic product. Based on the hardware manual, I was originally expecting a motor with an encoder, but this one doesn't have the encoder. Otherwise, it should be identical in functionality.

The TMC5272-EVAL-KIT comes in its own box, apparently assembled in Germany which is a rare find.

Inside, it seems three boards are packed into two static-shielding bags, carefully wrapped with egg-crate foam.

The three boards are as above - two of which have very decidedly-German names.

The board on the left appears mostly to be a computer USB interface board. It uses a GigaDevice ARM-based SoC to co-ordinate its operations and has a USB-C connection for data and power. There is a spot for an ESP-01 module for Wi-Fi connectivity, but this is not fitted. The name for this board? Landungsbrucke which translates into "landing bridge" or something similar. This is a fitting name, I suppose, given its function.

The board has a black silkscreen on white soldermask design and claims to be Open Source Hardware, which should mean that it's easy to modify and adapt for individual applications.

The next board is the Eselsbruecke which appears to directly translate to "donkey bridge" but also "mnemonic". It's function is a bridge for signals between boards, but perhaps the mnemonic function is the labelling of the signals. Or perhaps I'm just reading too deeply into this.

The final board is the stepper board itself, the TMC5272-EVAL. This particular board shows just how amazing the stepper driver chip is - just the small black square package inside of the black border. Apparently supporting two bipolar motors and two encoders, with up to 20V 0.8A drive. The size of the IC and the supporting components is just amazingly small.

I didn't detect any German-names on this board, which was a slight disappointment. But that's okay - I've already seen a lot more here than I normally do.

One thing I really appreciated about the board is the fact they didn't skimp out on the use of pluggable terminal blocks to make connecting and disconnecting connections easy. That being said, we are warned not to do this when power is applied - back EMF can be quite the risk!

I suppose this is how the three boards come together, with the headers lined up and pushed into place. One thing that annoys the perfectionist in me is just how the board edges and holes on the left board don't line up with the right board once they're snapped together. They're offset by a few millimeters. That won't affect the function, and seeing that these boards are not really intended for end-product usage, I suppose it's not a big deal as long as it doesn't annoy you when you're testing it.

Finally, we come to the included 12V 1A DC power supply from Multicomp Pro, an element14 brand.

Opening it up, I already like the fact there are multiple plugs for different countries and Australia is included!

Swapping plugs was rather easy, pushing down to release a tab that allows the plug module to slide out and a new plug to be clicked into place.

The output appears to be a 5.5mm outer diameter, 2.1mm inner diameter DC barrel plug, although this will need to be removed for use with the kit.

The branding is printed on the back side of the power supply, perhaps by laser etching.

The specifications and ratings are printed on the side, along with all of the inclusions. The model is DSA-12PFU-12FCA 120100 with a part number of MP001982 and order code 3293059.

Once all assembled, it fits into Australian plugs fine, and those "wings" can be "clipped" to help it fit better side-by-side with other plugs. No complaints here.

Conclusion

As it can be seen, everything that was promised did arrive on time, although the stepper motor wasn't quite the one we were originally expecting as this one doesn't have an encoder on it. But I don't see that as a major issue for me, as I'm not looking to have high-precision microstepping feedback or anything like that. Aside from that, I guess I'll need to do a little testing and hook everything up.

P.S.

Originally, I was aiming for a "one-a-day" posting regime to try and catch-up, but alas, the pain of my ankle condition has meant that even that is not achievable right now. I did make a start on a tiny-bit more, but not by much, so we'll see how much further I get by the due date. As I had feared in my first posting, there's a good chance I won't make it to the finish. Nevertheless, let it be on the record that at least I tried.

RangeDetect Rover 3# Using MKR wifi 1010 as TMC5272 Control board

fyaocn — Thu, 02 Jan 2025 03:23:37 GMT

3# Using MKR wifi 1010 as TMC5272 Control board

1 MKR WIFI 1010
2 Interface Connectors
3 Arduino Library
4 Coding
5 Summary

1 MKR WIFI 1010

he MKR WiFi 1010 is using popular Arm® Cortex®-M0 32-bit SAMD21 processor, it also features the and the ECC508 crypto-chip for security.

The MKR wifi 1010 uses 3.3V as GPIO and provides 5V from USB as output. This can drive TMC5272.

2 Interface Connectors

Here is the interface connector for TMC5272, The SPI interface 30,31,32,33 is key pins for stepper driver control,

Here is block diagram for function blocks,

Pin 20 USEL shall be put to GND for SPI selection and CLK to GND using internal clock.

Wiring the stepper motors

3 Arduino Library

The 735 lines arduino libray configurates the register for SPI to access

#define TMC5272_REGISTER_COUNT   128
#define TMC5272_MOTORS           2
#define TMC_WRITE_BIT            0x80
#define TMC_ADDRESS_MASK         0x7F
#define TMC5272_MAX_VELOCITY     8388096
#define TMC5272_MAX_ACCELERATION UINTN_MAX

// ramp modes (Register TMC5272_RAMPMODE)
#define TMC5272_MODE_POSITION  0
#define TMC5272_MODE_VELPOS    1
#define TMC5272_MODE_VELNEG    2
#define TMC5272_MODE_HOLD      3

// Registers in TMC5272

#define MOTOR_ADDR(m)      (0x35 * m)

#define TMC5272_GCONF                0x00
#define TMC5272_GSTAT                0x01
#define TMC5272_IFCNT                0x02
#define TMC5272_SLAVECONF            0x03
#define TMC5272_IOIN                 0x04
#define TMC5272_DRV_CONF             0x05
#define TMC5272_GLOBAL_SCALER        0x06
#define TMC5272_RAMPMODE             0x07
#define TMC5272_MSLUT_ADDR           0x08
#define TMC5272_MSLUT_SEL_START      0x09

										 // motor = 0       motor = 1
#define TMC5272_X_COMPARE(motor)          (0x10 + MOTOR_ADDR(motor))      //      0x10            0x45
#define TMC5272_X_COMPARE_REPEAT(motor)   (0x11 + MOTOR_ADDR(motor))      //      0x11            0x46
#define TMC5272_IHOLD_IRUN(motor)         (0x12 + MOTOR_ADDR(motor))      //      0x12            0x47
#define TMC5272_TPOWERDOWN(motor)         (0x13 + MOTOR_ADDR(motor))      //      0x13            0x48
#define TMC5272_TSTEP(motor)              (0x14 + MOTOR_ADDR(motor))      //      0x14            0x49
#define TMC5272_TPWMTHRS(motor)           (0x15 + MOTOR_ADDR(motor))      //      0x15            0x4A
#define TMC5272_TCOOLTHRS(motor)          (0x16 + MOTOR_ADDR(motor))      //      0x16            0x4B
#define TMC5272_THIGH(motor)              (0x17 + MOTOR_ADDR(motor))      //      0x17            0x4C
#define TMC5272_XACTUAL(motor)            (0x18 + MOTOR_ADDR(motor))      //      0x18            0x4D
#define TMC5272_VACTUAL(motor)            (0x19 + MOTOR_ADDR(motor))      //      0x19            0x4E
#define TMC5272_AACTUAL(motor)            (0x1A + MOTOR_ADDR(motor))      //      0x1A            0x4F
#define TMC5272_VSTART(motor)             (0x1B + MOTOR_ADDR(motor))      //      0x1B            0x50
#define TMC5272_A1(motor)                 (0x1C + MOTOR_ADDR(motor))      //      0x1C            0x51
#define TMC5272_V1(motor)                 (0x1D + MOTOR_ADDR(motor))      //      0x1D            0x52
#define TMC5272_A2(motor)                 (0x1E + MOTOR_ADDR(motor))      //      0x1E            0x53
#define TMC5272_V2(motor)                 (0x1F + MOTOR_ADDR(motor))      //      0x1F            0x54
#define TMC5272_AMAX(motor)               (0x20 + MOTOR_ADDR(motor))      //      0x20            0x55
#define TMC5272_VMAX(motor)               (0x21 + MOTOR_ADDR(motor))      //      0x21            0x56
#define TMC5272_DMAX(motor)               (0x22 + MOTOR_ADDR(motor))      //      0x22            0x57
#define TMC5272_D2(motor)                 (0x23 + MOTOR_ADDR(motor))      //      0x23            0x58
#define TMC5272_D1(motor)                 (0x24 + MOTOR_ADDR(motor))      //      0x24            0x59
#define TMC5272_VSTOP(motor)              (0x25 + MOTOR_ADDR(motor))      //      0x25            0x5A
#define TMC5272_TVMAX(motor)              (0x26 + MOTOR_ADDR(motor))      //      0x26            0x5B
#define TMC5272_TZEROWAIT(motor)          (0x27 + MOTOR_ADDR(motor))      //      0x27            0x5C
#define TMC5272_XTARGET(motor)            (0x28 + MOTOR_ADDR(motor))      //      0x28            0x5D
#define TMC5272_VDCMIN(motor)             (0x29 + MOTOR_ADDR(motor))      //      0x29            0x5E
#define TMC5272_SW_MODE(motor)            (0x2A + MOTOR_ADDR(motor))      //      0x2A            0x5F
#define TMC5272_RAMP_STAT(motor)          (0x2B + MOTOR_ADDR(motor))      //      0x2B            0x60
#define TMC5272_XLATCH(motor)             (0x2C + MOTOR_ADDR(motor))      //      0x2C            0x61
#define TMC5272_POSITION_PI_CTRL(motor)   (0x2D + MOTOR_ADDR(motor))      //      0x2D            0x62
#define TMC5272_X_ENC(motor)              (0x2E + MOTOR_ADDR(motor))      //      0x2E            0x63
#define TMC5272_ENCMODE(motor)            (0x2F + MOTOR_ADDR(motor))      //      0x2F            0x64
#define TMC5272_ENC_CONST(motor)          (0x30 + MOTOR_ADDR(motor))      //      0x30            0x65
#define TMC5272_ENC_STATUS(motor)         (0x31 + MOTOR_ADDR(motor))      //      0x31            0x66
#define TMC5272_ENC_LATCH(motor)          (0x32 + MOTOR_ADDR(motor))      //      0x32            0x67
#define TMC5272_ENC_DEVIATION(motor)      (0x33 + MOTOR_ADDR(motor))      //      0x33            0x68
#define TMC5272_VIRTUAL_STOP_L(motor)     (0x34 + MOTOR_ADDR(motor))      //      0x34            0x69
#define TMC5272_VIRTUAL_STOP_R(motor)     (0x35 + MOTOR_ADDR(motor))      //      0x35            0x6A
#define TMC5272_MSCNT(motor)              (0x36 + MOTOR_ADDR(motor))      //      0x36            0x6B
#define TMC5272_MSCURACT(motor)           (0x37 + MOTOR_ADDR(motor))      //      0x37            0x6C
#define TMC5272_CHOPCONF(motor)           (0x38 + MOTOR_ADDR(motor))      //      0x38            0x6D
#define TMC5272_COOLCONF(motor)           (0x39 + MOTOR_ADDR(motor))      //      0x39            0x6E
#define TMC5272_DCCTRL(motor)             (0x3A + MOTOR_ADDR(motor))      //      0x3A            0x6F
#define TMC5272_DRV_STATUS(motor)         (0x3B + MOTOR_ADDR(motor))      //      0x3B            0x70
#define TMC5272_PWMCONF(motor)            (0x3C + MOTOR_ADDR(motor))      //      0x3C            0x71
#define TMC5272_PWM_SCALE(motor)          (0x3D + MOTOR_ADDR(motor))      //      0x3D            0x72
#define TMC5272_PWM_AUTO(motor)           (0x3E + MOTOR_ADDR(motor))      //      0x3E            0x73
#define TMC5272_SG4_THRS(motor)           (0x3F + MOTOR_ADDR(motor))      //      0x3F            0x74
#define TMC5272_SG4_RESULT(motor)         (0x40 + MOTOR_ADDR(motor))      //      0x40            0x75
#define TMC5272_SG4_IND(motor)            (0x41 + MOTOR_ADDR(motor))      //      0x41            0x76

// Register fields in TMC5272

#define TMC5272_GCONF_M0_EN_PWM_MODE_MASK                     0x00000001
#define TMC5272_GCONF_M0_EN_PWM_MODE_SHIFT                    0
#define TMC5272_GCONF_M0_EN_PWM_MODE_FIELD                    ((RegisterField) { TMC5272_GCONF_M0_EN_PWM_MODE_MASK,  TMC5272_GCONF_M0_EN_PWM_MODE_SHIFT,  TMC5272_GCONF, false })
#define TMC5272_GCONF_M0_MULTISTEP_FILT_MASK                  0x00000002
#define TMC5272_GCONF_M0_MULTISTEP_FILT_SHIFT                 1
#define TMC5272_GCONF_M0_MULTISTEP_FILT_FIELD                 ((RegisterField) { TMC5272_GCONF_M0_MULTISTEP_FILT_MASK,  TMC5272_GCONF_M0_MULTISTEP_FILT_SHIFT,  TMC5272_GCONF, false })
#define TMC5272_GCONF_M0_SHAFT_MASK                           0x00000004
#define TMC5272_GCONF_M0_SHAFT_SHIFT                          2
#define TMC5272_GCONF_M0_SHAFT_FIELD(motor)                   (RegisterField) { TMC5272_GCONF_M0_SHAFT_MASK,  TMC5272_GCONF_M0_SHAFT_SHIFT,  TMC5272_GCONF, false })
#define TMC5272_GCONF_M0_DIAG0_ERROR_MASK                     0x00000008
#define TMC5272_GCONF_M0_DIAG0_ERROR_SHIFT                    3
#define TMC5272_GCONF_M0_DIAG0_ERROR_FIELD                    ((RegisterField) { TMC5272_GCONF_M0_DIAG0_ERROR_MASK,  TMC5272_GCONF_M0_DIAG0_ERROR_FIELD,  TMC5272_GCONF, false })
#define TMC5272_GCONF_DIAG0_OTPW_MASK                         0x00000010
#define TMC5272_GCONF_DIAG0_OTPW_SHIFT                        4
#define TMC5272_GCONF_DIAG0_OTPW_FIELD                        ((RegisterField) { TMC5272_GCONF_DIAG0_OTPW_MASK,  TMC5272_GCONF_DIAG0_OTPW_SHIFT,  TMC5272_GCONF, false })
#define TMC5272_GCONF_DIAG0_STALL_STEP_MASK                   0x00000020
#define TMC5272_GCONF_DIAG0_STALL_STEP_SHIFT                  5
#define TMC5272_GCONF_DIAG0_STALL_STEP_SHIF                   ((RegisterField) { TMC5272_GCONF_DIAG0_OTPW_MASK,  TMC5272_GCONF_DIAG0_OTPW_SHIFT,  TMC5272_GCONF, false })
#define TMC5272_GCONF_DIAG1_STALL_DIR_MASK                    0x00000040
#define TMC5272_GCONF_DIAG1_STALL_DIR_SHIFT                   6
#define TMC5272_GCONF_DIAG1_STALL_DIR_FIELD                   ((RegisterField) { TMC5272_GCONF_DIAG1_STALL_DIR_MASK,  TMC5272_GCONF_DIAG1_STALL_DIR_SHIFT,  TMC5272_GCONF, false })
#define TMC5272_GCONF_M0_DIAG1_INDEX_MASK                     0x00000080
#define TMC5272_GCONF_M0_DIAG1_INDEX_SHIFT                    7
#define TMC5272_GCONF_M0_DIAG1_INDEX_FIELD                    ((RegisterField) { TMC5272_GCONF_M0_DIAG1_INDEX_MASK,  TMC5272_GCONF_M0_DIAG1_INDEX_SHIFT,  TMC5272_GCONF, false })
#define TMC5272_GCONF_DIAG0_INT_PUSHPULL_MASK                 0x00000100
#define TMC5272_GCONF_DIAG0_INT_PUSHPULL_SHIFT                8
#define TMC5272_GCONF_DIAG0_INT_PUSHPULL_FIELD                ((RegisterField) { TMC5272_GCONF_M0_DIAG1_INDEX_MASK,  TMC5272_GCONF_M0_DIAG1_INDEX_SHIFT,  TMC5272_GCONF, false })
#define TMC5272_GCONF_DIAG1_POSCOMP_PUSHPULL_MASK             0x00000200
#define TMC5272_GCONF_DIAG1_POSCOMP_PUSHPULL_SHIFT            9
#define TMC5272_GCONF_DIAG1_POSCOMP_PUSHPULL_FIELD            ((RegisterField) { TMC5272_GCONF_DIAG1_POSCOMP_PUSHPULL_MASK,  TMC5272_GCONF_DIAG1_POSCOMP_PUSHPULL_SHIFT,  TMC5272_GCONF, false })
#define TMC5272_GCONF_M0_SMALL_HYSTERESIS_MASK                0x00000400
#define TMC5272_GCONF_M0_SMALL_HYSTERESIS_SHIFT               10
#define TMC5272_GCONF_M0_SMALL_HYSTERESIS_FIELD               ((RegisterField) { TMC5272_GCONF_M0_SMALL_HYSTERESIS_MASK,  TMC5272_GCONF_M0_SMALL_HYSTERESIS_SHIFT,  TMC5272_GCONF, false })
#define TMC5272_GCONF_M0_STOP_ENABLE_MASK                     0x00000800
#define TMC5272_GCONF_M0_STOP_ENABLE_SHIFT                    11
#define TMC5272_GCONF_M0_STOP_ENABLE_FIELD                    ((RegisterField) { TMC5272_GCONF_M0_STOP_ENABLE_MASK,  TMC5272_GCONF_M0_STOP_ENABLE_SHIFT,  TMC5272_GCONF, false })
#define TMC5272_GCONF_M0_DIRECT_MODE_MASK                     0x00001000
#define TMC5272_GCONF_M0_DIRECT_MODE_SHIFT                    12
#define TMC5272_GCONF_M0_DIRECT_MODE_FIELD                    ((RegisterField) { TMC5272_GCONF_M0_DIRECT_MODE_MASK,  TMC5272_GCONF_M0_DIRECT_MODE_SHIFT,  TMC5272_GCONF, false })
#define TMC5272_GCONF_M0_SD_MASK                              0x00002000
#define TMC5272_GCONF_M0_SD_SHIFT                             13
#define TMC5272_GCONF_M0_SD_FIELD                             ((RegisterField) { TMC5272_GCONF_M0_SD_MASK,  TMC5272_GCONF_M0_SD_SHIFT,  TMC5272_GCONF, false })
#define TMC5272_GCONF_M0_DRV_ENN_MASK                         0x00004000
#define TMC5272_GCONF_M0_DRV_ENN_SHIFT                        14
#define TMC5272_GCONF_M0_DRV_ENN_FIELD                        ((RegisterField) { TMC5272_GCONF_M0_DRV_ENN_MASK,  TMC5272_GCONF_M0_DRV_ENN_SHIFT,  TMC5272_GCONF, false })
#define TMC5272_GCONF_M1_EN_PWM_MODE_MASK                     0x00010000
#define TMC5272_GCONF_M1_EN_PWM_MODE_SHIFT                    16
#define TMC5272_GCONF_M1_EN_PWM_MODE_FIELD                    ((RegisterField) { TMC5272_GCONF_M1_EN_PWM_MODE_MASK,  TMC5272_GCONF_M1_EN_PWM_MODE_SHIFT,  TMC5272_GCONF, false })
#define TMC5272_GCONF_M1_MULTISTEP_FILT_MASK                  0x00020000
#define TMC5272_GCONF_M1_MULTISTEP_FILT_SHIFT                 17
#define TMC5272_GCONF_M1_MULTISTEP_FILT_FIELD                 ((RegisterField) { TMC5272_GCONF_M1_MULTISTEP_FILT_MASK,  TMC5272_GCONF_M1_MULTISTEP_FILT_SHIFT,  TMC5272_GCONF, false })
#define TMC5272_GCONF_M1_SHAFT_MASK                           0x00040000
#define TMC5272_GCONF_M1_SHAFT_SHIFT                          18
#define TMC5272_GCONF_M1_SHAFT_FIELD                          ((RegisterField) { TMC5272_GCONF_M1_SHAFT_MASK,  TMC5272_GCONF_M1_SHAFT_SHIFT,  TMC5272_GCONF, false })
#define TMC5272_GCONF_DIAG0_INTOUT_SEL_MASK                   0x00180000
#define TMC5272_GCONF_DIAG0_INTOUT_SEL_SHIFT                  19
#define TMC5272_GCONF_DIAG0_INTOUT_SEL_FIELD                  ((RegisterField) { TMC5272_GCONF_DIAG0_INTOUT_SEL_MASK,  TMC5272_GCONF_DIAG0_INTOUT_SEL_SHIFT,  TMC5272_GCONF, false })
#define TMC5272_GCONF_DIAG1_X_COMP_SEL_MASK                   0x00600000
#define TMC5272_GCONF_DIAG1_X_COMP_SEL_SHIFT                  21
#define TMC5272_GCONF_DIAG1_X_COMP_SEL_FIELD                  ((RegisterField) { TMC5272_GCONF_DIAG1_X_COMP_SEL_MASK,  TMC5272_GCONF_DIAG1_X_COMP_SEL_SHIFT,  TMC5272_GCONF, false })
#define TMC5272_GCONF_M1_DIAG1_INDEX_MASK                     0x00800000
#define TMC5272_GCONF_M1_DIAG1_INDEX_SHIFT                    23
#define TMC5272_GCONF_M1_DIAG1_INDEX_FIELD                    ((RegisterField) { TMC5272_GCONF_M1_DIAG1_INDEX_MASK,  TMC5272_GCONF_M1_DIAG1_INDEX_SHIFT,  TMC5272_GCONF, false })
#define TMC5272_GCONF_M1_SMALL_HYSTERESIS_MASK                0x01000000
#define TMC5272_GCONF_M1_SMALL_HYSTERESIS_SHIFT               24
#define TMC5272_GCONF_M1_SMALL_HYSTERESIS_FIELD               ((RegisterField) { TMC5272_GCONF_M1_DIAG1_INDEX_MASK,  TMC5272_GCONF_M1_DIAG1_INDEX_SHIFT,  TMC5272_GCONF, false })
#define TMC5272_GCONF_M1_STOP_ENABLE_MASK                     0x02000000
#define TMC5272_GCONF_M1_STOP_ENABLE_SHIFT                    25
#define TMC5272_GCONF_M1_STOP_ENABLE_FIELD                    ((RegisterField) { TMC5272_GCONF_M1_STOP_ENABLE_MASK,  TMC5272_GCONF_M1_STOP_ENABLE_SHIFT,  TMC5272_GCONF, false })
#define TMC5272_GCONF_M1_DIRECT_MODE_MASK                     0x04000000
#define TMC5272_GCONF_M1_DIRECT_MODE_SHIFT                    26
#define TMC5272_GCONF_M1_DIRECT_MODE_FIELD                    ((RegisterField) { TMC5272_GCONF_M1_DIRECT_MODE_MASK,  TMC5272_GCONF_M1_DIRECT_MODE_SHIFT,  TMC5272_GCONF, false })
#define TMC5272_GCONF_M1_SD_MASK                              0x08000000
#define TMC5272_GCONF_M1_SD_SHIFT                             27
#define TMC5272_GCONF_M1_SD_FIELD                             ((RegisterField) { TMC5272_GCONF_M1_SD_MASK,  TMC5272_GCONF_M1_SD_SHIFT,  TMC5272_GCONF, false })
#define TMC5272_GCONF_M1_DRV_ENN_MASK                         0x10000000
#define TMC5272_GCONF_M1_DRV_ENN_SHIFT                        28
#define TMC5272_GCONF_M1_DRV_ENN_FIELD                        ((RegisterField) { TMC5272_GCONF_M1_DRV_ENN_MASK,  TMC5272_GCONF_M1_DRV_ENN_SHIFT,  TMC5272_GCONF, false })
#define TMC5272_GSTAT_RESET_MASK                              0x00000001
#define TMC5272_GSTAT_RESET_SHIFT                             0
#define TMC5272_GSTAT_RESET_FIELD                             ((RegisterField) { TMC5272_GSTAT_RESET_MASK,  TMC5272_GSTAT_RESET_SHIFT,  TMC5272_GSTAT, false })
#define TMC5272_GSTAT_M0_DRV_ERR_MASK                         0x00000002
#define TMC5272_GSTAT_M0_DRV_ERR_SHIFT                        1
#define TMC5272_GSTAT_M0_DRV_ERR_FIELD                        ((RegisterField) { TMC5272_GSTAT_M0_DRV_ERR_MASK,  TMC5272_GSTAT_M0_DRV_ERR_SHIFT,  TMC5272_GSTAT, false })
#define TMC5272_GSTAT_UV_CP_MASK                              0x00000004
#define TMC5272_GSTAT_UV_CP_SHIFT                             2
#define TMC5272_GSTAT_UV_CP_FIELD                             ((RegisterField) { TMC5272_GSTAT_UV_CP_MASK,  TMC5272_GSTAT_UV_CP_SHIFT,  TMC5272_GSTAT, false })
#define TMC5272_GSTAT_REGISTER_RESET_MASK                     0x00000008
#define TMC5272_GSTAT_REGISTER_RESET_SHIFT                    3
#define TMC5272_GSTAT_REGISTER_RESET_FIELD                    ((RegisterField) { TMC5272_GSTAT_REGISTER_RESET_MASK,  TMC5272_GSTAT_REGISTER_RESET_SHIFT,  TMC5272_GSTAT, false })
#define TMC5272_GSTAT_VM_UVLO_MASK                            0x00000010
#define TMC5272_GSTAT_VM_UVLO_SHIFT                           4
#define TMC5272_GSTAT_VM_UVLO_FIELD                           ((RegisterField) { TMC5272_GSTAT_VM_UVLO_MASK,  TMC5272_GSTAT_VM_UVLO_SHIFT,  TMC5272_GSTAT, false })
#define TMC5272_GSTAT_M1_DRV_ERR_MASK                         0x00000020
#define TMC5272_GSTAT_M1_DRV_ERR_SHIFT                        5
#define TMC5272_GSTAT_M1_DRV_ERR_FIELD                        ((RegisterField) { TMC5272_GSTAT_M1_DRV_ERR_MASK,  TMC5272_GSTAT_M1_DRV_ERR_SHIFT,  TMC5272_GSTAT, false })
#define TMC5272_IFCNT_MASK                                    0x000000FF
#define TMC5272_IFCNT_SHIFT                                   0
#define TMC5272_IFCNT_FIELD                                   ((RegisterField) { TMC5272_IFCNT_MASK,  TMC5272_IFCNT_SHIFT,  TMC5272_IFCNT, false })
#define TMC5272_SLAVECONF_SLAVEADDR_MASK                      0x000000FF
#define TMC5272_SLAVECONF_SLAVEADDR_SHIFT                     0
#define TMC5272_SLAVECONF_SLAVEADDR_FIELD                     ((RegisterField) { TMC5272_SLAVECONF_SLAVEADDR_MASK,  TMC5272_SLAVECONF_SLAVEADDR_SHIFT,  TMC5272_SLAVECONF, false })
#define TMC5272_SLAVECONF_SENDDELAY_MASK                      0x00000F00
#define TMC5272_SLAVECONF_SENDDELAY_SHIFT                     8
#define TMC5272_SLAVECONF_SENDDELAY_FIELD                     ((RegisterField) { TMC5272_SLAVECONF_SENDDELAY_MASK,  TMC5272_SLAVECONF_SENDDELAY_SHIFT,  TMC5272_SLAVECONF, false })
#define TMC5272_IOIN_ADC_TEMPERATURE_MASK                     0x000001FE
#define TMC5272_IOIN_ADC_TEMPERATURE_SHIFT                    1
#define TMC5272_IOIN_ADC_TEMPERATURE_FIELD                    ((RegisterField) { TMC5272_IOIN_ADC_TEMPERATURE_MASK,  TMC5272_IOIN_ADC_TEMPERATURE_SHIFT,  TMC5272_IOIN, false })
#define TMC5272_IOIN_ADC_EN_MASK                              0x00000200
#define TMC5272_IOIN_ADC_EN_SHIFT                             9
#define TMC5272_IOIN_ADC_EN_FIELD                             ((RegisterField) { TMC5272_IOIN_ADC_EN_MASK,  TMC5272_IOIN_ADC_EN_SHIFT,  TMC5272_IOIN, false })
#define TMC5272_IOIN_SEL_OSCILLATOR_MASK                      0x00000800
#define TMC5272_IOIN_SEL_OSCILLATOR_SHIFT                     11
#define TMC5272_IOIN_SEL_OSCILLATOR_FIELD                     ((RegisterField) { TMC5272_IOIN_SEL_OSCILLATOR_MASK,  TMC5272_IOIN_SEL_OSCILLATOR_SHIFT,  TMC5272_IOIN, false })
#define TMC5272_IOIN_EXT_RES_DET_MASK                         0x00001000
#define TMC5272_IOIN_EXT_RES_DET_SHIFT                        12
#define TMC5272_IOIN_EXT_RES_DET_FIELD                        ((RegisterField) { TMC5272_IOIN_EXT_RES_DET_MASK,  TMC5272_IOIN_EXT_RES_DET_SHIFT,  TMC5272_IOIN, false })
#define TMC5272_IOIN_OUTPUT_MASK                              0x00002000
#define TMC5272_IOIN_OUTPUT_SHIFT                             13
#define TMC5272_IOIN_OUTPUT_FIELD                             ((RegisterField) { TMC5272_IOIN_EXT_RES_DET_MASK,  TMC5272_IOIN_EXT_RES_DET_SHIFT,  TMC5272_IOIN, false })
#define TMC5272_IOIN_QSC_STATUS_MASK                          0x00008000
#define TMC5272_IOIN_QSC_STATUS_SHIFT                         15
#define TMC5272_IOIN_QSC_STATUS_FIELD                         ((RegisterField) { TMC5272_IOIN_QSC_STATUS_MASK,  TMC5272_IOIN_QSC_STATUS_SHIFT,  TMC5272_IOIN, false })
#define TMC5272_IOIN_SILICON_RV_MASK                          0x00070000
#define TMC5272_IOIN_SILICON_RV_SHIFT                         16
#define TMC5272_IOIN_SILICON_RV_FIELD                         ((RegisterField) { TMC5272_IOIN_SILICON_RV_MASK,  TMC5272_IOIN_SILICON_RV_SHIFT,  TMC5272_IOIN, false })
#define TMC5272_IOIN_VERSION_MASK                             0xFF000000
#define TMC5272_IOIN_VERSION_SHIFT                            24
#define TMC5272_IOIN_VERSION_FIELD                            ((RegisterField) { TMC5272_IOIN_VERSION_MASK,  TMC5272_IOIN_VERSION_SHIFT,  TMC5272_IOIN, false })
#define TMC5272_DRV_CONF_FSR_M0_MASK                          0x00000003
#define TMC5272_DRV_CONF_FSR_M0_SHIFT                         0
#define TMC5272_DRV_CONF_FSR_M0_FIELD                         ((RegisterField) { TMC5272_DRV_CONF_FSR_M0_MASK,  TMC5272_DRV_CONF_FSR_M0_SHIFT,  TMC5272_DRV_CONF, false })
#define TMC5272_DRV_CONF_FSR_IREF_M0_MASK                     0x0000000C
#define TMC5272_DRV_CONF_FSR_IREF_M0_SHIFT                    2
#define TMC5272_DRV_CONF_FSR_IREF_M0_FIELD                         ((RegisterField) { TMC5272_DRV_CONF_FSR_IREF_M0_MASK,  TMC5272_DRV_CONF_FSR_IREF_M0_SHIFT,  TMC5272_DRV_CONF, false })
#define TMC5272_DRV_CONF_M0_EN_EMERGENCY_DISABLE_MASK         0x00000010
#define TMC5272_DRV_CONF_M0_EN_EMERGENCY_DISABLE_SHIFT        4
#define TMC5272_DRV_CONF_M0_EN_EMERGENCY_DISABLE_FIELD        ((RegisterField) { TMC5272_DRV_CONF_M0_EN_EMERGENCY_DISABLE_MASK,  TMC5272_DRV_CONF_M0_EN_EMERGENCY_DISABLE_SHIFT,  TMC5272_DRV_CONF, false })
#define TMC5272_DRV_CONF_M0_SEL_EM_STOP_SRC_MASK              0x00000020
#define TMC5272_DRV_CONF_M0_SEL_EM_STOP_SRC_SHIFT             5
#define TMC5272_DRV_CONF_M0_SEL_EM_STOP_SRC_FIELD             ((RegisterField) { TMC5272_DRV_CONF_M0_SEL_EM_STOP_SRC_MASK,  TMC5272_DRV_CONF_M0_SEL_EM_STOP_SRC_SHIFT,  TMC5272_DRV_CONF, false })
#define TMC5272_DRV_CONF_FSR_M1_MASK                          0x000000C0
#define TMC5272_DRV_CONF_FSR_M1_SHIFT                         6
#define TMC5272_DRV_CONF_FSR_M1_FIELD                         ((RegisterField) { TMC5272_DRV_CONF_FSR_M1_MASK,  TMC5272_DRV_CONF_FSR_M1_SHIFT,  TMC5272_DRV_CONF, false })
#define TMC5272_DRV_CONF_FSR_IREF_M1_MASK                     0x00000300
#define TMC5272_DRV_CONF_FSR_IREF_M1_SHIFT                    8
#define TMC5272_DRV_CONF_FSR_IREF_M1_FIELD                    ((RegisterField) { TMC5272_DRV_CONF_FSR_IREF_M1_MASK,  TMC5272_DRV_CONF_FSR_IREF_M1_SHIFT,  TMC5272_DRV_CONF, false })
#define TMC5272_DRV_CONF_M1_EN_EMERGENCY_DISABLE_MASK         0x00000400
#define TMC5272_DRV_CONF_M1_EN_EMERGENCY_DISABLE_SHIFT        10
#define TMC5272_DRV_CONF_M1_EN_EMERGENCY_DISABLE1_FIELD       ((RegisterField) { TMC5272_DRV_CONF_M1_EN_EMERGENCY_DISABLE_MASK,  TMC5272_DRV_CONF_M1_EN_EMERGENCY_DISABLE_SHIFT,  TMC5272_DRV_CONF, false })
#define TMC5272_DRV_CONF_M1_SEL_EM_STOP_SRC_MASK              0x00000800
#define TMC5272_DRV_CONF_M1_SEL_EM_STOP_SRC_SHIFT             11
#define TMC5272_DRV_CONF_M1_SEL_EM_STOP_SRC_FIELD             ((RegisterField) { TMC5272_DRV_CONF_M1_SEL_EM_STOP_SRC_MASK,  TMC5272_DRV_CONF_M1_SEL_EM_STOP_SRC_SHIFT,  TMC5272_DRV_CONF, false })
#define TMC5272_DRV_CONF_M0_STANDSTILL_TIME_MASK              0x00070000
#define TMC5272_DRV_CONF_M0_STANDSTILL_TIME_SHIFT             16
#define TMC5272_DRV_CONF_M0_STANDSTILL_TIME_FIELD             ((RegisterField) { TMC5272_DRV_CONF_M0_STANDSTILL_TIME_MASK,  TMC5272_DRV_CONF_M0_STANDSTILL_TIME_SHIFT,  TMC5272_DRV_CONF, false })
#define TMC5272_DRV_CONF_M1_STANDSTILL_TIME_MASK              0x00700000
#define TMC5272_DRV_CONF_M1_STANDSTILL_TIME_SHIFT             20
#define TMC5272_DRV_CONF_M1_STANDSTILL_TIME_FIELD             ((RegisterField) { TMC5272_DRV_CONF_M1_STANDSTILL_TIME_MASK,  TMC5272_DRV_CONF_M1_STANDSTILL_TIME_SHIFT,  TMC5272_DRV_CONF, false })
#define TMC5272_GLOBAL_SCALER_GLOBALSCALER_M0_A_MASK          0x000000FF
#define TMC5272_GLOBAL_SCALER_GLOBALSCALER_M0_A_SHIFT         0
#define TMC5272_GLOBAL_SCALER_GLOBALSCALER_M0_A_FIELD         ((RegisterField) { TMC5272_GLOBAL_SCALER_GLOBALSCALER_M0_A_MASK,  TMC5272_GLOBAL_SCALER_GLOBALSCALER_M0_A_SHIFT,  TMC5272_GLOBAL_SCALER, false })
#define TMC5272_GLOBAL_SCALER_GLOBALSCALER_M0_B_MASK          0x0000FF00
#define TMC5272_GLOBAL_SCALER_GLOBALSCALER_M0_B_SHIFT         8
#define TMC5272_GLOBAL_SCALER_GLOBALSCALER_M0_B_FIELD         ((RegisterField) { TMC5272_GLOBAL_SCALER_GLOBALSCALER_M0_B_MASK,  TMC5272_GLOBAL_SCALER_GLOBALSCALER_M0_B_SHIFT,  TMC5272_GLOBAL_SCALER, false })
#define TMC5272_GLOBAL_SCALER_GLOBALSCALER_M1_A_MASK          0x00FF0000
#define TMC5272_GLOBAL_SCALER_GLOBALSCALER_M1_A_SHIFT         16
#define TMC5272_GLOBAL_SCALER_GLOBALSCALER_M1_A_FIELD         ((RegisterField) { TMC5272_GLOBAL_SCALER_GLOBALSCALER_M1_A_MASK,  TMC5272_GLOBAL_SCALER_GLOBALSCALER_M1_A_SHIFT,  TMC5272_GLOBAL_SCALER, false })
#define TMC5272_GLOBAL_SCALER_GLOBALSCALER_M1_B_MASK          0xFF000000
#define TMC5272_GLOBAL_SCALER_GLOBALSCALER_M1_B_SHIFT         24
#define TMC5272_GLOBAL_SCALER_GLOBALSCALER_M1_B_FIELD         ((RegisterField) { TMC5272_GLOBAL_SCALER_GLOBALSCALER_M1_B_MASK,  TMC5272_GLOBAL_SCALER_GLOBALSCALER_M1_B_SHIFT,  TMC5272_GLOBAL_SCALER, false })
#define TMC5272_RAMPMODE_M0_RAMPMODE_MASK                     0x00000003
#define TMC5272_RAMPMODE_M0_RAMPMODE_SHIFT                    0
#define TMC5272_RAMPMODE_M0_RAMPMODE_FIELD                    ((RegisterField) { TMC5272_RAMPMODE_M0_RAMPMODE_MASK,  TMC5272_RAMPMODE_M0_RAMPMODE_SHIFT,  TMC5272_RAMPMODE, false })
#define TMC5272_RAMPMODE_M1_RAMPMODE_MASK                     0x0000000C
#define TMC5272_RAMPMODE_M1_RAMPMODE_SHIFT                    2
#define TMC5272_RAMPMODE_M1_RAMPMODE_FIELD                    ((RegisterField) { TMC5272_RAMPMODE_M1_RAMPMODE_MASK,  TMC5272_RAMPMODE_M1_RAMPMODE_SHIFT,  TMC5272_RAMPMODE, false })
#define TMC5272_RAMPMODE_SHIFT(motor)                         (2 * (motor))
#define TMC5272_RAMPMODE_MASK(motor)                          (TMC5272_RAMPMODE_M0_RAMPMODE_MASK << TMC5272_RAMPMODE_SHIFT(motor))
#define TMC5272_RAMPMODE_FIELD(motor)                         ((RegisterField) { TMC5272_RAMPMODE_MASK(motor),  TMC5272_RAMPMODE_SHIFT(motor),  TMC5272_RAMPMODE, false })
#define TMC5272_RAMPMODE_RAMP0_HOLD_MASK                      0x00000100
#define TMC5272_RAMPMODE_RAMP0_HOLD_SHIFT                     8
#define TMC5272_RAMPMODE_RAMP0_HOLD_FIELD                     ((RegisterField) { TMC5272_RAMPMODE_RAMP0_HOLD_MASK,  TMC5272_RAMPMODE_RAMP0_HOLD_SHIFT,  TMC5272_RAMPMODE, false })
#define TMC5272_RAMPMODE_RAMP1_HOLD_MASK                      0x00000200
#define TMC5272_RAMPMODE_RAMP1_HOLD_SHIFT                     9
#define TMC5272_RAMPMODE_RAMP1_HOLD_FIELD                     ((RegisterField) { TMC5272_RAMPMODE_RAMP1_HOLD_MASK,  TMC5272_RAMPMODE_RAMP1_HOLD_SHIFT,  TMC5272_RAMPMODE, false })
#define TMC5272_MSLUT_ADDR_MASK                               0x0000001F
#define TMC5272_MSLUT_ADDR_SHIFT                              0
#define TMC5272_MSLUT_ADDR_FIELD                              ((RegisterField) { TMC5272_MSLUT_ADDR_MASK,  TMC5272_MSLUT_ADDR_SHIFT,  TMC5272_MSLUT_ADDR, false })
#define TMC5272_MSLUT_START_START_SIN_MASK                    0xFF
#define TMC5272_MSLUT_START_START_SIN_SHIFT                   0
#define TMC5272_MSLUT_START_START_SIN_FIELD                   ((RegisterField) { TMC5272_MSLUT_START_START_SIN_MASK,  TMC5272_MSLUT_START_START_SIN_SHIFT,  TMC5272_MSLUT_SEL_START, false })
#define TMC5272_MSLUT_START_START_SIN90_MASK                  0xFF0000
#define TMC5272_MSLUT_START_START_SIN90_SHIFT                 16
#define TMC5272_MSLUT_START_START_SIN90_FIELD                 ((RegisterField) { TMC5272_MSLUT_START_START_SIN90_MASK,  TMC5272_MSLUT_START_START_SIN90_SHIFT,  TMC5272_MSLUT_SEL_START, false })
#define TMC5272_MSLUT_START_OFFSET_SIN90_MASK                 0xFF000000
#define TMC5272_MSLUT_START_OFFSET_SIN90_SHIFT                24
#define TMC5272_MSLUT_START_OFFSET_SIN90_FIELD                ((RegisterField) { TMC5272_MSLUT_START_OFFSET_SIN90_MASK,  TMC5272_MSLUT_START_OFFSET_SIN90_SHIFT,  TMC5272_MSLUT_SEL_START, false })
#define TMC5272_X_COMPARE_MASK                                0xFFFFFFFF
#define TMC5272_X_COMPARE_SHIFT                               0
#define TMC5272_X_COMPARE_FIELD(motor)                        ((RegisterField) { TMC5272_X_COMPARE_MASK,  TMC5272_X_COMPARE_SHIFT,  TMC5272_X_COMPARE(motor), false })
#define TMC5272_X_COMPARE_REPEAT_MASK                         0x00FFFFFF
#define TMC5272_X_COMPARE_REPEAT_SHIFT                        0
#define TMC5272_X_COMPARE_REPEAT_FIELD(motor)                 ((RegisterField) { TMC5272_X_COMPARE_REPEAT_MASK,  TMC5272_X_COMPARE_REPEAT_SHIFT,  TMC5272_X_COMPARE_REPEAT(motor), false })
#define TMC5272_IHOLD_IRUN_IHOLD_MASK                         0x0000001F
#define TMC5272_IHOLD_IRUN_IHOLD_SHIFT                        0
#define TMC5272_IHOLD_IRUN_IHOLD_FIELD(motor)                 ((RegisterField) { TMC5272_IHOLD_IRUN_IHOLD_MASK,  TMC5272_IHOLD_IRUN_IHOLD_SHIFT,  TMC5272_IHOLD_IRUN(motor), false })
#define TMC5272_IHOLD_IRUN_IRUN_MASK                          0x00001F00
#define TMC5272_IHOLD_IRUN_IRUN_SHIFT                         8
#define TMC5272_IHOLD_IRUN_IRUN_FIELD(motor)                  ((RegisterField) { TMC5272_IHOLD_IRUN_IRUN_MASK,  TMC5272_IHOLD_IRUN_IRUN_SHIFT,  TMC5272_IHOLD_IRUN(motor), false })
#define TMC5272_IHOLD_IRUN_IHOLDDELAY_MASK                    0x000F0000
#define TMC5272_IHOLD_IRUN_IHOLDDELAY_SHIFT                   16
#define TMC5272_IHOLD_IRUN_IHOLDDELAY_FIELD(motor)            ((RegisterField) { TMC5272_IHOLD_IRUN_IHOLDDELAY_MASK,  TMC5272_IHOLD_IRUN_IHOLDDELAY_SHIFT,  TMC5272_IHOLD_IRUN(motor), false })
#define TMC5272_IHOLD_IRUN_IRUNDELAY_MASK                     0x0F000000
#define TMC5272_IHOLD_IRUN_IRUNDELAY_SHIFT                    24
#define TMC5272_IHOLD_IRUN_IRUNDELAY_FIELD(motor)             ((RegisterField) { TMC5272_IHOLD_IRUN_IRUNDELAY_MASK,  TMC5272_IHOLD_IRUN_IRUNDELAY_SHIFT,  TMC5272_IHOLD_IRUN(motor), false })
#define TMC5272_TPOWERDOWN_MASK                               0x000000FF
#define TMC5272_TPOWERDOWN_SHIFT                              0
#define TMC5272_TPOWERDOWN_FIELD(motor)                       ((RegisterField) { TMC5272_TPOWERDOWN_MASK,  TMC5272_TPOWERDOWN_SHIFT,  TMC5272_TPOWERDOWN(motor), false })
#define TMC5272_TSTEP_MASK                                    0x000FFFFF
#define TMC5272_TSTEP_SHIFT                                   0
#define TMC5272_TSTEP_FIELD(motor)                            ((RegisterField) { TMC5272_TSTEP_MASK,  TMC5272_TSTEP_SHIFT,  TMC5272_TSTEP(motor), false })
#define TMC5272_TPWMTHRS_MASK                                 0x000FFFFF
#define TMC5272_TPWMTHRS_SHIFT                                0
#define TMC5272_TPWMTHRS_FIELD(motor)                         ((RegisterField) { TMC5272_TPWMTHRS_MASK,  TMC5272_TPWMTHRS_SHIFT,  TMC5272_TPWMTHRS(motor), false })
#define TMC5272_TCOOLTHRS_MASK                                0x000FFFFF
#define TMC5272_TCOOLTHRS_SHIFT                               0
#define TMC5272_TCOOLTHRS_FIELD(motor)                        ((RegisterField) { TMC5272_TCOOLTHRS_MASK,  TMC5272_TCOOLTHRS_SHIFT,  TMC5272_TCOOLTHRS(motor), false })
#define TMC5272_THIGH_MASK                                    0x000FFFFF
#define TMC5272_THIGH_SHIFT                                   0
#define TMC5272_THIGH_FIELD(motor)                            ((RegisterField) { TMC5272_THIGH_MASK,  TMC5272_THIGH_SHIFT,  TMC5272_THIGH(motor), false })
#define TMC5272_XACTUAL_MASK                                  0xFFFFFFFF
#define TMC5272_XACTUAL_SHIFT                                 0
#define TMC5272_XACTUAL_FIELD(motor)                          ((RegisterField) { TMC5272_XACTUAL_MASK,  TMC5272_XACTUAL_SHIFT,  TMC5272_XACTUAL(motor), false })
#define TMC5272_VACTUAL_MASK                                  0x00FFFFFF
#define TMC5272_VACTUAL_SHIFT                                 0
#define TMC5272_VACTUAL_FIELD(motor)                          ((RegisterField) { TMC5272_VACTUAL_MASK,  TMC5272_VACTUAL_SHIFT,  TMC5272_VACTUAL(motor), false })
#define TMC5272_AACTUAL_MASK                                  0x00FFFFFF
#define TMC5272_AACTUAL_SHIFT                                 0
#define TMC5272_AACTUAL_FIELD(motor)                          ((RegisterField) { TMC5272_AACTUAL_MASK,  TMC5272_AACTUAL_SHIFT,  TMC5272_AACTUAL(motor), false })
#define TMC5272_VSTART_MASK                                   0x0003FFFF
#define TMC5272_VSTART_SHIFT                                  0
#define TMC5272_VSTART_FIELD(motor)                           ((RegisterField) { TMC5272_VSTART_MASK,  TMC5272_VSTART_SHIFT,  TMC5272_VSTART(motor), false })
#define TMC5272_A1_MASK                                       0x0003FFFF
#define TMC5272_A1_SHIFT                                      0
#define TMC5272_A1_FIELD(motor)                               ((RegisterField) { TMC5272_A1_MASK,  TMC5272_A1_SHIFT,  TMC5272_A1(motor), false })
#define TMC5272_V1_MASK                                       0x000FFFFF
#define TMC5272_V1_SHIFT                                      0
#define TMC5272_V1_FIELD(motor)                               ((RegisterField) { TMC5272_V1_MASK,  TMC5272_V1_SHIFT,  TMC5272_V1(motor), false })
#define TMC5272_A2_MASK                                       0x0003FFFF
#define TMC5272_A2_SHIFT                                      0
#define TMC5272_A2_FIELD(motor)                               ((RegisterField) { TMC5272_A2_MASK,  TMC5272_A2_SHIFT,  TMC5272_A2(motor), false })
#define TMC5272_V2_MASK                                       0x000FFFFF
#define TMC5272_V2_SHIFT                                      0
#define TMC5272_V2_FIELD(motor)                               ((RegisterField) { TMC5272_V2_MASK,  TMC5272_V2_SHIFT,  TMC5272_V2(motor), false })
#define TMC5272_AMAX_MASK                                     0x0003FFFF
#define TMC5272_AMAX_SHIFT                                    0
#define TMC5272_AMAX_FIELD(motor)                             ((RegisterField) { TMC5272_AMAX_MASK,  TMC5272_AMAX_SHIFT,  TMC5272_AMAX(motor), false })
#define TMC5272_VMAX_MASK                                     0x007FFFFF
#define TMC5272_VMAX_SHIFT                                    0
#define TMC5272_VMAX_FIELD(motor)                             ((RegisterField) { TMC5272_VMAX_MASK,  TMC5272_VMAX_SHIFT,  TMC5272_VMAX(motor), false })
#define TMC5272_DMAX_MASK                                     0x0003FFFF
#define TMC5272_DMAX_SHIFT                                    0
#define TMC5272_DMAX_FIELD(motor)                             ((RegisterField) { TMC5272_DMAX_MASK,  TMC5272_DMAX_SHIFT,  TMC5272_DMAX(motor), false })
#define TMC5272_D2_MASK                                       0x0003FFFF
#define TMC5272_D2_SHIFT                                      0
#define TMC5272_D2_FIELD(motor)                               ((RegisterField) { TMC5272_D2_MASK,  TMC5272_D2_SHIFT,  TMC5272_D2(motor), false })
#define TMC5272_D1_MASK                                       0x0003FFFF
#define TMC5272_D1_SHIFT                                      0
#define TMC5272_D1_FIELD(motor)                               ((RegisterField) { TMC5272_D1_MASK,  TMC5272_D1_SHIFT,  TMC5272_D1(motor), false })
#define TMC5272_VSTOP_MASK                                    0x0003FFFF
#define TMC5272_VSTOP_SHIFT                                   0
#define TMC5272_VSTOP_FIELD(motor)                            ((RegisterField) { TMC5272_VSTOP_MASK,  TMC5272_VSTOP_SHIFT,  TMC5272_VSTOP(motor), false })
#define TMC5272_TVMAX_MASK                                    0x0000FFFF
#define TMC5272_TVMAX_SHIFT                                   0
#define TMC5272_TVMAX_FIELD(motor)                            ((RegisterField) { TMC5272_TVMAX_MASK,  TMC5272_TVMAX_SHIFT,  TMC5272_TVMAX(motor), false })
#define TMC5272_TZEROWAIT_MASK                                0x0000FFFF
#define TMC5272_TZEROWAIT_SHIFT                               0
#define TMC5272_TZEROWAIT_FIELD(motor)                        ((RegisterField) { TMC5272_TZEROWAIT_MASK,  TMC5272_TZEROWAIT_SHIFT,  TMC5272_TZEROWAIT(motor), false })
#define TMC5272_XTARGET_MASK                                  0xFFFFFFFF
#define TMC5272_XTARGET_SHIFT                                 0
#define TMC5272_XTARGET_FIELD(motor)                          ((RegisterField) { TMC5272_XTARGET_MASK,  TMC5272_XTARGET_SHIFT,  TMC5272_XTARGET(motor), false })
#define TMC5272_VDCMIN_RESERVED_MASK                          0x000000FF
#define TMC5272_VDCMIN_RESERVED_SHIFT                         0
#define TMC5272_VDCMIN_RESERVED_FIELD(motor)                  ((RegisterField) { TMC5272_VDCMIN_RESERVED_MASK,  TMC5272_VDCMIN_RESERVED_SHIFT,  TMC5272_VDCMIN(motor), false })
#define TMC5272_VDCMIN_VDCMIN_MASK                            0x007FFF00
#define TMC5272_VDCMIN_VDCMIN_SHIFT                           8
#define TMC5272_VDCMIN_VDCMIN_FIELD(motor)                    ((RegisterField) { TMC5272_VDCMIN_VDCMIN_MASK,  TMC5272_VDCMIN_VDCMIN_SHIFT,  TMC5272_VDCMIN(motor), false })
#define TMC5272_SW_MODE_STOP_L_ENABLE_MASK                    0x00000001
#define TMC5272_SW_MODE_STOP_L_ENABLE_SHIFT                   0
#define TMC5272_SW_MODE_STOP_L_ENABLE_FIELD(motor)            ((RegisterField) { TMC5272_SW_MODE_STOP_L_ENABLE_MASK,  TMC5272_SW_MODE_STOP_L_ENABLE_SHIFT,  TMC5272_SW_MODE(motor), false })
#define TMC5272_SW_MODE_STOP_R_ENABLE_MASK                    0x00000002
#define TMC5272_SW_MODE_STOP_R_ENABLE_SHIFT                   1
#define TMC5272_SW_MODE_STOP_R_ENABLE_FIELD(motor)            ((RegisterField) { TMC5272_SW_MODE_STOP_R_ENABLE_MASK,  TMC5272_SW_MODE_STOP_R_ENABLE_SHIFT,  TMC5272_SW_MODE(motor), false })
#define TMC5272_SW_MODE_POL_STOP_L_MASK                       0x00000004
#define TMC5272_SW_MODE_POL_STOP_L_SHIFT                      2
#define TMC5272_SW_MODE_POL_STOP_L_FIELD(motor)               ((RegisterField) { TMC5272_SW_MODE_POL_STOP_L_MASK,  TMC5272_SW_MODE_POL_STOP_L_SHIFT,  TMC5272_SW_MODE(motor), false })
#define TMC5272_SW_MODE_POL_STOP_R_MASK                       0x00000008
#define TMC5272_SW_MODE_POL_STOP_R_SHIFT                      3
#define TMC5272_SW_MODE_POL_STOP_R_FIELD(motor)               ((RegisterField) { TMC5272_SW_MODE_POL_STOP_R_MASK,  TMC5272_SW_MODE_POL_STOP_R_SHIFT,  TMC5272_SW_MODE(motor), false })
#define TMC5272_SW_MODE_SWAP_LR_MASK                          0x00000010
#define TMC5272_SW_MODE_SWAP_LR_SHIFT                         4
#define TMC5272_SW_MODE_SWAP_LR_FIELD(motor)                  ((RegisterField) { TMC5272_SW_MODE_SWAP_LR_MASK,  TMC5272_SW_MODE_SWAP_LR_SHIFT,  TMC5272_SW_MODE(motor), false })
#define TMC5272_SW_MODE_LATCH_L_ACTIVE_MASK                   0x00000020
#define TMC5272_SW_MODE_LATCH_L_ACTIVE_SHIFT                  5
#define TMC5272_SW_MODE_LATCH_L_ACTIVE_FIELD(motor)           ((RegisterField) { TMC5272_SW_MODE_LATCH_L_ACTIVE_MASK,  TMC5272_SW_MODE_LATCH_L_ACTIVE_SHIFT,  TMC5272_SW_MODE(motor), false })
#define TMC5272_SW_MODE_LATCH_L_INACTIVE_MASK                 0x00000040
#define TMC5272_SW_MODE_LATCH_L_INACTIVE_SHIFT                6
#define TMC5272_SW_MODE_LATCH_L_INACTIVE_FIELD(motor)         ((RegisterField) { TMC5272_SW_MODE_LATCH_L_INACTIVE_MASK,  TMC5272_SW_MODE_LATCH_L_ACTIVE_SHIFT,  TMC5272_SW_MODE(motor), false })
#define TMC5272_SW_MODE_LATCH_R_ACTIVE_MASK                   0x00000080
#define TMC5272_SW_MODE_LATCH_R_ACTIVE_SHIFT                  7
#define TMC5272_SW_MODE_LATCH_R_ACTIVE_FIELD(motor)           ((RegisterField) { TMC5272_SW_MODE_LATCH_R_ACTIVE_MASK,  TMC5272_SW_MODE_LATCH_R_ACTIVE_SHIFT,  TMC5272_SW_MODE(motor), false })
#define TMC5272_SW_MODE_LATCH_R_INACTIVE_MASK                 0x00000100
#define TMC5272_SW_MODE_LATCH_R_INACTIVE_SHIFT                8
#define TMC5272_SW_MODE_LATCH_R_INACTIVE_FIELD(motor)         ((RegisterField) { TMC5272_SW_MODE_LATCH_R_INACTIVE_MASK,  TMC5272_SW_MODE_LATCH_R_INACTIVE_SHIFT,  TMC5272_SW_MODE(motor), false })
#define TMC5272_SW_MODE_EN_LATCH_ENCODER_MASK                 0x00000200
#define TMC5272_SW_MODE_EN_LATCH_ENCODER_SHIFT                9
#define TMC5272_SW_MODE_EN_LATCH_ENCODER_FIELD(motor)         ((RegisterField) { TMC5272_SW_MODE_EN_LATCH_ENCODER_MASK,  TMC5272_SW_MODE_EN_LATCH_ENCODER_SHIFT,  TMC5272_SW_MODE(motor), false })
#define TMC5272_SW_MODE_SG_STOP_MASK                          0x00000400
#define TMC5272_SW_MODE_SG_STOP_SHIFT                         10
#define TMC5272_SW_MODE_SG_STOP_FIELD(motor)                  ((RegisterField) { TMC5272_SW_MODE_SG_STOP_MASK,  TMC5272_SW_MODE_SG_STOP_SHIFT,  TMC5272_SW_MODE(motor), false })
#define TMC5272_SW_MODE_EN_SOFTSTOP_MASK                      0x00000800
#define TMC5272_SW_MODE_EN_SOFTSTOP_SHIFT                     11
#define TMC5272_SW_MODE_EN_SOFTSTOP_FIELD(motor)              ((RegisterField) { TMC5272_SW_MODE_EN_SOFTSTOP_MASK,  TMC5272_SW_MODE_EN_SOFTSTOP_SHIFT,  TMC5272_SW_MODE(motor), false })
#define TMC5272_SW_MODE_EN_VIRTUAL_STOP_L_MASK                0x00001000
#define TMC5272_SW_MODE_EN_VIRTUAL_STOP_L_SHIFT               12
#define TMC5272_SW_MODE_EN_VIRTUAL_STOP_L_FIELD(motor)        ((RegisterField) { TMC5272_SW_MODE_EN_SOFTSTOP_MASK,  TMC5272_SW_MODE_EN_SOFTSTOP_SHIFT,  TMC5272_SW_MODE(motor), false })
#define TMC5272_SW_MODE_EN_VIRTUAL_STOP_R_MASK                0x00002000
#define TMC5272_SW_MODE_EN_VIRTUAL_STOP_R_SHIFT               13
#define TMC5272_SW_MODE_EN_VIRTUAL_STOP_R_FIELD(motor)        ((RegisterField) { TMC5272_SW_MODE_EN_VIRTUAL_STOP_R_MASK,  TMC5272_SW_MODE_EN_VIRTUAL_STOP_R_SHIFT,  TMC5272_SW_MODE(motor), false })
#define TMC5272_SW_MODE_VIRTUAL_STEP_ENC_MASK                 0x00004000
#define TMC5272_SW_MODE_VIRTUAL_STEP_ENC_SHIFT                14
#define TMC5272_SW_MODE_VIRTUAL_STEP_ENC_FIELD(motor)         ((RegisterField) { TMC5272_SW_MODE_VIRTUAL_STEP_ENC_MASK,  TMC5272_SW_MODE_VIRTUAL_STEP_ENC_SHIFT,  TMC5272_SW_MODE(motor), false })
#define TMC5272_RAMP_STAT_STATUS_STOP_L_MASK                  0x00000001
#define TMC5272_RAMP_STAT_STATUS_STOP_L_SHIFT                 0
#define TMC5272_RAMP_STAT_STATUS_STOP_L_FIELD(motor)          ((RegisterField) { TMC5272_RAMP_STAT_STATUS_STOP_L_MASK,  TMC5272_RAMP_STAT_STATUS_STOP_L_SHIFT,  TMC5272_RAMP_STAT(motor), false })
#define TMC5272_RAMP_STAT_STATUS_STOP_R_MASK                  0x00000002
#define TMC5272_RAMP_STAT_STATUS_STOP_R_SHIFT                 1
#define TMC5272_RAMP_STAT_STATUS_STOP_R_FIELD(motor)          ((RegisterField) { TMC5272_RAMP_STAT_STATUS_STOP_R_MASK,  TMC5272_RAMP_STAT_STATUS_STOP_R_SHIFT,  TMC5272_RAMP_STAT(motor), false })
#define TMC5272_RAMP_STAT_STATUS_LATCH_L_MASK                 0x00000004
#define TMC5272_RAMP_STAT_STATUS_LATCH_L_SHIFT                2
#define TMC5272_RAMP_STAT_STATUS_LATCH_L_FIELD(motor)         ((RegisterField) { TMC5272_RAMP_STAT_STATUS_LATCH_L_MASK,  TMC5272_RAMP_STAT_STATUS_LATCH_L_FIELD(motor),  TMC5272_RAMP_STAT(motor), false })
#define TMC5272_RAMP_STAT_STATUS_LATCH_R_MASK                 0x00000008
#define TMC5272_RAMP_STAT_STATUS_LATCH_R_SHIFT                3
#define TMC5272_RAMP_STAT_STATUS_LATCH_R_FIELD(motor)         ((RegisterField) { TMC5272_RAMP_STAT_STATUS_LATCH_R_MASK,  TMC5272_RAMP_STAT_STATUS_LATCH_R_SHIFT,  TMC5272_RAMP_STAT(motor), false })
#define TMC5272_RAMP_STAT_EVENT_STOP_L_MASK                   0x00000010
#define TMC5272_RAMP_STAT_EVENT_STOP_L_SHIFT                  4
#define TMC5272_RAMP_STAT_EVENT_STOP_L_FIELD(motor)           ((RegisterField) { TMC5272_RAMP_STAT_EVENT_STOP_L_MASK,  TMC5272_RAMP_STAT_EVENT_STOP_L_SHIFT,  TMC5272_RAMP_STAT(motor), false })
#define TMC5272_RAMP_STAT_EVENT_STOP_R_MASK                   0x00000020
#define TMC5272_RAMP_STAT_EVENT_STOP_R_SHIFT                  5
#define TMC5272_RAMP_STAT_EVENT_STOP_R_FIELD(motor)           ((RegisterField) { TMC5272_RAMP_STAT_EVENT_STOP_R_MASK,  TMC5272_RAMP_STAT_EVENT_STOP_R_SHIFT,  TMC5272_RAMP_STAT(motor), false })
#define TMC5272_RAMP_STAT_EVENT_STOP_SG_MASK                  0x00000040
#define TMC5272_RAMP_STAT_EVENT_STOP_SG_SHIFT                 6
#define TMC5272_RAMP_STAT_EVENT_STOP_SG_FIELD(motor)          ((RegisterField) { TMC5272_RAMP_STAT_EVENT_STOP_SG_MASK,  TMC5272_RAMP_STAT_EVENT_STOP_SG_SHIFT,  TMC5272_RAMP_STAT(motor), false })
#define TMC5272_RAMP_STAT_EVENT_POS_REACHED_MASK              0x00000080
#define TMC5272_RAMP_STAT_EVENT_POS_REACHED_SHIFT             7
#define TMC5272_RAMP_STAT_EVENT_POS_REACHED_FIELD(motor)      ((RegisterField) { TMC5272_RAMP_STAT_EVENT_POS_REACHED_MASK,  TMC5272_RAMP_STAT_EVENT_POS_REACHED_SHIFT,  TMC5272_RAMP_STAT(motor), false })
#define TMC5272_RAMP_STAT_VELOCITY_REACHED_MASK               0x00000100
#define TMC5272_RAMP_STAT_VELOCITY_REACHED_SHIFT              8
#define TMC5272_RAMP_STAT_VELOCITY_REACHED_FIELD(motor)       ((RegisterField) { TMC5272_RAMP_STAT_VELOCITY_REACHED_MASK,  TMC5272_RAMP_STAT_VELOCITY_REACHED_SHIFT,  TMC5272_RAMP_STAT(motor), false })
#define TMC5272_RAMP_STAT_POSITION_REACHED_MASK               0x00000200
#define TMC5272_RAMP_STAT_POSITION_REACHED_SHIFT              9
#define TMC5272_RAMP_STAT_POSITION_REACHED_FIELD(motor)       ((RegisterField) { TMC5272_RAMP_STAT_POSITION_REACHED_MASK,  TMC5272_RAMP_STAT_POSITION_REACHED_SHIFT,  TMC5272_RAMP_STAT(motor), false })
#define TMC5272_RAMP_STAT_VZERO_MASK                          0x00000400
#define TMC5272_RAMP_STAT_VZERO_SHIFT                         10
#define TMC5272_RAMP_STAT_VZERO_FIELD(motor)                  ((RegisterField) { TMC5272_RAMP_STAT_VZERO_MASK,  TMC5272_RAMP_STAT_VZERO_SHIFT,  TMC5272_RAMP_STAT(motor), false })
#define TMC5272_RAMP_STAT_T_ZEROWAIT_ACTIVE_MASK              0x00000800
#define TMC5272_RAMP_STAT_T_ZEROWAIT_ACTIVE_SHIFT             11
#define TMC5272_RAMP_STAT_T_ZEROWAIT_ACTIVE_FIELD(motor)      ((RegisterField) { TMC5272_RAMP_STAT_T_ZEROWAIT_ACTIVE_MASK,  TMC5272_RAMP_STAT_T_ZEROWAIT_ACTIVE_SHIFT,  TMC5272_RAMP_STAT(motor), false })
#define TMC5272_RAMP_STAT_SECOND_MOVE_MASK                    0x00001000
#define TMC5272_RAMP_STAT_SECOND_MOVE_SHIFT                   12
#define TMC5272_RAMP_STAT_SECOND_MOVE_FIELD(motor)            ((RegisterField) { TMC5272_RAMP_STAT_SECOND_MOVE_MASK,  TMC5272_RAMP_STAT_SECOND_MOVE_SHIFT,  TMC5272_RAMP_STAT(motor), false })
#define TMC5272_RAMP_STAT_STATUS_SG_MASK                      0x00002000
#define TMC5272_RAMP_STAT_STATUS_SG_SHIFT                     13
#define TMC5272_RAMP_STAT_STATUS_SG_FIELD(motor)              ((RegisterField) { TMC5272_RAMP_STAT_STATUS_SG_MASK,  TMC5272_RAMP_STAT_STATUS_SG_SHIFT,  TMC5272_RAMP_STAT(motor), false })
#define TMC5272_RAMP_STAT_STATUS_VIRTUAL_STOP_L_MASK          0x00004000
#define TMC5272_RAMP_STAT_STATUS_VIRTUAL_STOP_L_SHIFT         14
#define TMC5272_RAMP_STAT_STATUS_VIRTUAL_STOP_L_FIELD(motor)  ((RegisterField) { TMC5272_RAMP_STAT_STATUS_VIRTUAL_STOP_L_MASK,  TMC5272_RAMP_STAT_STATUS_VIRTUAL_STOP_L_SHIFT,  TMC5272_RAMP_STAT(motor), false })
#define TMC5272_RAMP_STAT_STATUS_VIRTUAL_STOP_R_MASK          0x00008000
#define TMC5272_RAMP_STAT_STATUS_VIRTUAL_STOP_R_SHIFT         15
#define TMC5272_RAMP_STAT_STATUS_VIRTUAL_STOP_R_FIELD(motor)  ((RegisterField) { TMC5272_RAMP_STAT_STATUS_VIRTUAL_STOP_R_MASK,  TMC5272_RAMP_STAT_STATUS_VIRTUAL_STOP_R_SHIFT,  TMC5272_RAMP_STAT(motor), false })
#define TMC5272_XLATCH_MASK                                   0xFFFFFFFF
#define TMC5272_XLATCH_SHIFT                                  0
#define TMC5272_XLATCH_FIELD(motor)                           ((RegisterField) { TMC5272_XLATCH_MASK,  TMC5272_XLATCH_SHIFT,  TMC5272_XLATCH(motor), false })
#define TMC5272_POSITION_PI_CTRL_POSITION_PI_CTRL_REGS_MASK   0xFFFFFFFF
#define TMC5272_POSITION_PI_CTRL_POSITION_PI_CTRL_REGS_SHIFT  0
#define TMC5272_POSITION_PI_CTRL_POSITION_PI_CTRL_REGS_FIELD(motor)  ((RegisterField) { TMC5272_POSITION_PI_CTRL_POSITION_PI_CTRL_REGS_MASK,  TMC5272_POSITION_PI_CTRL_POSITION_PI_CTRL_REGS_SHIFT,  TMC5272_POSITION_PI_CTRL(motor), false })
#define TMC5272_X_ENC_MASK                                    0xFFFFFFFF
#define TMC5272_X_ENC_SHIFT                                   0
#define TMC5272_X_ENC_FIELD(motor)                            ((RegisterField) { TMC5272_X_ENC_MASK,  TMC5272_X_ENC_SHIFT,  TMC5272_X_ENC(motor), false })
#define TMC5272_ENCMODE_POL_A_MASK                            0x00000001
#define TMC5272_ENCMODE_POL_A_SHIFT                           0
#define TMC5272_ENCMODE_POL_A_FIELD(motor)                    ((RegisterField) { TMC5272_ENCMODE_POL_A_MASK,  TMC5272_ENCMODE_POL_A_SHIFT,  TMC5272_ENCMODE(motor), false })
#define TMC5272_ENCMODE_POL_B_MASK                            0x00000002
#define TMC5272_ENCMODE_POL_B_SHIFT                           1
#define TMC5272_ENCMODE_POL_B_FIELD(motor)                    ((RegisterField) { TMC5272_ENCMODE_POL_B_MASK,  TMC5272_ENCMODE_POL_B_SHIFT,  TMC5272_ENCMODE(motor), false })
#define TMC5272_ENCMODE_POL_N_MASK                            0x00000004
#define TMC5272_ENCMODE_POL_N_SHIFT                           2
#define TMC5272_ENCMODE_POL_N_FIELD(motor)                    ((RegisterField) { TMC5272_ENCMODE_POL_N_MASK,  TMC5272_ENCMODE_POL_N_SHIFT,  TMC5272_ENCMODE(motor), false })
#define TMC5272_ENCMODE_IGNORE_AB_MASK                        0x00000008
#define TMC5272_ENCMODE_IGNORE_AB_SHIFT                       3
#define TMC5272_ENCMODE_IGNORE_AB_FIELD(motor)                ((RegisterField) { TMC5272_ENCMODE_IGNORE_AB_MASK,  TMC5272_ENCMODE_IGNORE_AB_SHIFT,  TMC5272_ENCMODE(motor), false })
#define TMC5272_ENCMODE_CLR_CONT_MASK                         0x00000010
#define TMC5272_ENCMODE_CLR_CONT_SHIFT                        4
#define TMC5272_ENCMODE_CLR_CONT_FIELD(motor)                 ((RegisterField) { TMC5272_ENCMODE_CLR_CONT_MASK,  TMC5272_ENCMODE_CLR_CONT_SHIFT,  TMC5272_ENCMODE(motor), false })
#define TMC5272_ENCMODE_CLR_ONCE_MASK                         0x00000020
#define TMC5272_ENCMODE_CLR_ONCE_SHIFT                        5
#define TMC5272_ENCMODE_CLR_ONCE_FIELD(motor)                 ((RegisterField) { TMC5272_ENCMODE_CLR_ONCE_MASK,  TMC5272_ENCMODE_CLR_ONCE_SHIFT,  TMC5272_ENCMODE(motor), false })
#define TMC5272_ENCMODE_POS_NEG_EDGE_MASK                     0x000000C0
#define TMC5272_ENCMODE_POS_NEG_EDGE_SHIFT                    6
#define TMC5272_ENCMODE_POS_NEG_EDGE_FIELD(motor)             ((RegisterField) { TMC5272_ENCMODE_POS_NEG_EDGE_MASK,  TMC5272_ENCMODE_POS_NEG_EDGE_SHIFT,  TMC5272_ENCMODE(motor), false })
#define TMC5272_ENCMODE_CLR_ENC_X_MASK                        0x00000100
#define TMC5272_ENCMODE_CLR_ENC_X_SHIFT                       8
#define TMC5272_ENCMODE_CLR_ENC_X_FIELD(motor)                ((RegisterField) { TMC5272_ENCMODE_CLR_ENC_X_MASK,  TMC5272_ENCMODE_CLR_ENC_X_SHIFT,  TMC5272_ENCMODE(motor), false })
#define TMC5272_ENCMODE_LATCH_X_ACT_MASK                      0x00000200
#define TMC5272_ENCMODE_LATCH_X_ACT_SHIFT                     9
#define TMC5272_ENCMODE_LATCH_X_ACT_FIELD(motor)              ((RegisterField) { TMC5272_ENCMODE_LATCH_X_ACT_MASK,  TMC5272_ENCMODE_LATCH_X_ACT_SHIFT,  TMC5272_ENCMODE(motor), false })
#define TMC5272_ENCMODE_ENC_SEL_DECIMAL_MASK                  0x00000400
#define TMC5272_ENCMODE_ENC_SEL_DECIMAL_SHIFT                 10
#define TMC5272_ENCMODE_ENC_SEL_DECIMAL_FIELD(motor)          ((RegisterField) { TMC5272_ENCMODE_ENC_SEL_DECIMAL_MASK,  TMC5272_ENCMODE_ENC_SEL_DECIMAL_SHIFT,  TMC5272_ENCMODE(motor), false })
#define TMC5272_ENCMODE_NBEMF_ABN_SEL_MASK                    0x00000800
#define TMC5272_ENCMODE_NBEMF_ABN_SEL_SHIFT                   11
#define TMC5272_ENCMODE_NBEMF_ABN_SEL_FIELD(motor)            ((RegisterField) { TMC5272_ENCMODE_NBEMF_ABN_SEL_MASK,  TMC5272_ENCMODE_NBEMF_ABN_SEL_SHIFT,  TMC5272_ENCMODE(motor), false })
#define TMC5272_ENCMODE_BEMF_HYST_MASK                        0x00007000
#define TMC5272_ENCMODE_BEMF_HYST_SHIFT                       12
#define TMC5272_ENCMODE_BEMF_HYST_FIELD(motor)                ((RegisterField) { TMC5272_ENCMODE_BEMF_HYST_MASK,  TMC5272_ENCMODE_BEMF_HYST_SHIFT,  TMC5272_ENCMODE(motor), false })
#define TMC5272_ENCMODE_BEMF_BLANK_TIME_MASK                  0x00FF0000
#define TMC5272_ENCMODE_BEMF_BLANK_TIME_SHIFT                 16
#define TMC5272_ENCMODE_BEMF_BLANK_TIME_FIELD(motor)          ((RegisterField) { TMC5272_ENCMODE_BEMF_BLANK_TIME_MASK,  TMC5272_ENCMODE_BEMF_BLANK_TIME_SHIFT,  TMC5272_ENCMODE(motor), false })
#define TMC5272_ENC_CONST_MASK                                0xFFFFFFFF
#define TMC5272_ENC_CONST_SHIFT                               0
#define TMC5272_ENC_CONST_FIELD(motor)                        ((RegisterField) { TMC5272_ENC_CONST_MASK,  TMC5272_ENC_CONST_SHIFT,  TMC5272_ENC_CONST(motor), false })
#define TMC5272_ENC_STATUS_N_EVENT_MASK                       0x00000001
#define TMC5272_ENC_STATUS_N_EVENT_SHIFT                      0
#define TMC5272_ENC_STATUS_N_EVENT_FIELD(motor)               ((RegisterField) { TMC5272_ENC_STATUS_N_EVENT_MASK,  TMC5272_ENC_STATUS_N_EVENT_SHIFT,  TMC5272_ENC_STATUS(motor), false })
#define TMC5272_ENC_STATUS_DEVIATION_WARN_MASK                0x00000002
#define TMC5272_ENC_STATUS_DEVIATION_WARN_SHIFT               1
#define TMC5272_ENC_STATUS_DEVIATION_WARN_FIELD(motor)        ((RegisterField) { TMC5272_ENC_STATUS_DEVIATION_WARN_MASK,  TMC5272_ENC_STATUS_DEVIATION_WARN_SHIFT,  TMC5272_ENC_STATUS(motor), false })
#define TMC5272_ENC_LATCH_MASK                                0xFFFFFFFF
#define TMC5272_ENC_LATCH_SHIFT                               0
#define TMC5272_ENC_LATCH_FIELD(motor)                        ((RegisterField) { TMC5272_ENC_LATCH_MASK,  TMC5272_ENC_LATCH_SHIFT,  TMC5272_ENC_LATCH(motor), false })
#define TMC5272_ENC_DEVIATION_MASK                            0x000FFFFF
#define TMC5272_ENC_DEVIATION_SHIFT                           0
#define TMC5272_ENC_DEVIATION_FIELD(motor)                    ((RegisterField) { TMC5272_ENC_DEVIATION_MASK,  TMC5272_ENC_DEVIATION_SHIFT,  TMC5272_ENC_DEVIATION(motor), false })
#define TMC5272_VIRTUAL_STOP_L_MASK                           0xFFFFFFFF
#define TMC5272_VIRTUAL_STOP_L_SHIFT                          0
#define TMC5272_VIRTUAL_STOP_L_FIELD(motor)                   ((RegisterField) { TMC5272_VIRTUAL_STOP_L_MASK,  TMC5272_VIRTUAL_STOP_L_SHIFT,  TMC5272_VIRTUAL_STOP_L(motor), false })
#define TMC5272_VIRTUAL_STOP_R_MASK                           0xFFFFFFFF
#define TMC5272_VIRTUAL_STOP_R_SHIFT                          0
#define TMC5272_VIRTUAL_STOP_R_FIELD(motor)                   ((RegisterField) { TMC5272_VIRTUAL_STOP_R_MASK,  TMC5272_VIRTUAL_STOP_R_SHIFT,  TMC5272_VIRTUAL_STOP_R(motor), false })
#define TMC5272_MSCNT_MASK                                    0x000003FF
#define TMC5272_MSCNT_SHIFT                                   0
#define TMC5272_MSCNT_FIELD(motor)                            ((RegisterField) { TMC5272_MSCNT_MASK,  TMC5272_MSCNT_SHIFT,  TMC5272_MSCNT(motor), false })
#define TMC5272_MSCURACT_CUR_A_MASK                           0x000001FF
#define TMC5272_MSCURACT_CUR_A_SHIFT                          0
#define TMC5272_MSCURACT_CUR_A_FIELD(motor)                   ((RegisterField) { TMC5272_MSCURACT_CUR_A_MASK,  TMC5272_MSCURACT_CUR_A_SHIFT,  TMC5272_MSCURACT(motor), false })
#define TMC5272_MSCURACT_CUR_B_MASK                           0x01FF0000
#define TMC5272_MSCURACT_CUR_B_SHIFT                          16
#define TMC5272_MSCURACT_CUR_B_FIELD(motor)                   ((RegisterField) { TMC5272_MSCURACT_CUR_B_MASK,  TMC5272_MSCURACT_CUR_B_SHIFT,  TMC5272_MSCURACT(motor), false })
#define TMC5272_CHOPCONF_TOFF_MASK                            0x0000000F
#define TMC5272_CHOPCONF_TOFF_SHIFT                           0
#define TMC5272_CHOPCONF_TOFF_FIELD(motor)                    ((RegisterField) { TMC5272_CHOPCONF_TOFF_MASK,  TMC5272_CHOPCONF_TOFF_SHIFT,  TMC5272_CHOPCONF(motor), false })
#define TMC5272_CHOPCONF_HSTRT_TFD210_MASK                    0x00000070
#define TMC5272_CHOPCONF_HSTRT_TFD210_SHIFT                   4
#define TMC5272_CHOPCONF_HSTRT_TFD210_FIELD(motor)            ((RegisterField) { TMC5272_CHOPCONF_HSTRT_TFD210_MASK,  TMC5272_CHOPCONF_HSTRT_TFD210_SHIFT,  TMC5272_CHOPCONF(motor), false })
#define TMC5272_CHOPCONF_HEND_OFFSET_MASK                     0x00000780
#define TMC5272_CHOPCONF_HEND_OFFSET_SHIFT                    7
#define TMC5272_CHOPCONF_HEND_OFFSET_FIELD(motor)             ((RegisterField) { TMC5272_CHOPCONF_HEND_OFFSET_MASK,  TMC5272_CHOPCONF_HEND_OFFSET_SHIFT,  TMC5272_CHOPCONF(motor), false })
#define TMC5272_CHOPCONF_FD3_MASK                             0x00000800
#define TMC5272_CHOPCONF_FD3_SHIFT                            11
#define TMC5272_CHOPCONF_FD3_FIELD(motor)                     ((RegisterField) { TMC5272_CHOPCONF_FD3_MASK,  TMC5272_CHOPCONF_FD3_SHIFT,  TMC5272_CHOPCONF(motor), false })
#define TMC5272_CHOPCONF_DISFDCC_MASK                         0x00001000
#define TMC5272_CHOPCONF_DISFDCC_SHIFT                        12
#define TMC5272_CHOPCONF_DISFDCC_FIELD(motor)                 ((RegisterField) { TMC5272_CHOPCONF_DISFDCC_MASK,  TMC5272_CHOPCONF_DISFDCC_SHIFT,  TMC5272_CHOPCONF(motor), false })
#define TMC5272_CHOPCONF_CHM_MASK                             0x00004000
#define TMC5272_CHOPCONF_CHM_SHIFT                            14
#define TMC5272_CHOPCONF_CHM_FIELD(motor)                     ((RegisterField) { TMC5272_CHOPCONF_CHM_MASK,  TMC5272_CHOPCONF_CHM_SHIFT,  TMC5272_CHOPCONF(motor), false })
#define TMC5272_CHOPCONF_TBL_MASK                             0x00018000
#define TMC5272_CHOPCONF_TBL_SHIFT                            15
#define TMC5272_CHOPCONF_TBL_FIELD(motor)                     ((RegisterField) { TMC5272_CHOPCONF_TBL_MASK,  TMC5272_CHOPCONF_TBL_SHIFT,  TMC5272_CHOPCONF(motor), false })
#define TMC5272_CHOPCONF_VHIGHFS_MASK                         0x00040000
#define TMC5272_CHOPCONF_VHIGHFS_SHIFT                        18
#define TMC5272_CHOPCONF_VHIGHFS_FIELD(motor)                 ((RegisterField) { TMC5272_CHOPCONF_VHIGHFS_MASK,  TMC5272_CHOPCONF_VHIGHFS_SHIFT,  TMC5272_CHOPCONF(motor), false })
#define TMC5272_CHOPCONF_VHIGHCHM_MASK                        0x00080000
#define TMC5272_CHOPCONF_VHIGHCHM_SHIFT                       19
#define TMC5272_CHOPCONF_VHIGHCHM_FIELD(motor)                ((RegisterField) { TMC5272_CHOPCONF_VHIGHCHM_MASK,  TMC5272_CHOPCONF_VHIGHCHM_SHIFT,  TMC5272_CHOPCONF(motor), false })
#define TMC5272_CHOPCONF_TPFD_MASK                            0x00F00000
#define TMC5272_CHOPCONF_TPFD_SHIFT                           20
#define TMC5272_CHOPCONF_TPFD_FIELD(motor)                    ((RegisterField) { TMC5272_CHOPCONF_TPFD_MASK,  TMC5272_CHOPCONF_TPFD_SHIFT,  TMC5272_CHOPCONF(motor), false })
#define TMC5272_CHOPCONF_MRES_MASK                            0x0F000000
#define TMC5272_CHOPCONF_MRES_SHIFT                           24
#define TMC5272_CHOPCONF_MRES_FIELD(motor)                    ((RegisterField) { TMC5272_CHOPCONF_MRES_MASK,  TMC5272_CHOPCONF_MRES_SHIFT,  TMC5272_CHOPCONF(motor), false })
#define TMC5272_CHOPCONF_INTPOL_MASK                          0x10000000
#define TMC5272_CHOPCONF_INTPOL_SHIFT                         28
#define TMC5272_CHOPCONF_INTPOL_FIELD(motor)                  ((RegisterField) { TMC5272_CHOPCONF_INTPOL_MASK,  TMC5272_CHOPCONF_INTPOL_SHIFT,  TMC5272_CHOPCONF(motor), false })
#define TMC5272_CHOPCONF_DEDGE_MASK                           0x20000000
#define TMC5272_CHOPCONF_DEDGE_SHIFT                          29
#define TMC5272_CHOPCONF_DEDGE_FIELD(motor)                   ((RegisterField) { TMC5272_CHOPCONF_DEDGE_MASK,  TMC5272_CHOPCONF_DEDGE_SHIFT,  TMC5272_CHOPCONF(motor), false })
#define TMC5272_CHOPCONF_DISS2G_MASK                          0x40000000
#define TMC5272_CHOPCONF_DISS2G_SHIFT                         30
#define TMC5272_CHOPCONF_DISS2G_FIELD(motor)                  ((RegisterField) { TMC5272_CHOPCONF_DISS2G_MASK,  TMC5272_CHOPCONF_DISS2G_SHIFT,  TMC5272_CHOPCONF(motor), false })
#define TMC5272_CHOPCONF_DISS2VS_MASK                         0x80000000
#define TMC5272_CHOPCONF_DISS2VS_SHIFT                        31
#define TMC5272_CHOPCONF_DISS2VS_FIELD(motor)                 ((RegisterField) { TMC5272_CHOPCONF_DISS2VS_MASK,  TMC5272_CHOPCONF_DISS2VS_SHIFT,  TMC5272_CHOPCONF(motor), false })
#define TMC5272_COOLCONF_SEMIN_MASK                           0x0000000F
#define TMC5272_COOLCONF_SEMIN_SHIFT                          0
#define TMC5272_COOLCONF_SEMIN_FIELD(motor)                   ((RegisterField) { TMC5272_COOLCONF_SEMIN_MASK,  TMC5272_COOLCONF_SEMIN_SHIFT,  TMC5272_COOLCONF(motor), false })
#define TMC5272_COOLCONF_SEUP_MASK                            0x00000060
#define TMC5272_COOLCONF_SEUP_SHIFT                           5
#define TMC5272_COOLCONF_SEUP_FIELD(motor)                    ((RegisterField) { TMC5272_COOLCONF_SEUP_MASK,  TMC5272_COOLCONF_SEUP_SHIFT,  TMC5272_COOLCONF(motor), false })
#define TMC5272_COOLCONF_SEMAX_MASK                           0x00000F00
#define TMC5272_COOLCONF_SEMAX_SHIFT                          8
#define TMC5272_COOLCONF_SEMAX_FIELD(motor)                   ((RegisterField) { TMC5272_COOLCONF_SEMAX_MASK,  TMC5272_COOLCONF_SEMAX_SHIFT,  TMC5272_COOLCONF(motor), false })
#define TMC5272_COOLCONF_SEDN_MASK                            0x00006000
#define TMC5272_COOLCONF_SEDN_SHIFT                           13
#define TMC5272_COOLCONF_SEDN_FIELD(motor)                    ((RegisterField) { TMC5272_COOLCONF_SEDN_MASK,  TMC5272_COOLCONF_SEDN_SHIFT,  TMC5272_COOLCONF(motor), false })
#define TMC5272_COOLCONF_SEIMIN_MASK                          0x00008000
#define TMC5272_COOLCONF_SEIMIN_SHIFT                         15
#define TMC5272_COOLCONF_SEIMIN_FIELD(motor)                  ((RegisterField) { TMC5272_COOLCONF_SEIMIN_MASK,  TMC5272_COOLCONF_SEIMIN_SHIFT,  TMC5272_COOLCONF(motor), false })
#define TMC5272_COOLCONF_SGT_MASK                             0x007F0000
#define TMC5272_COOLCONF_SGT_SHIFT                            16
#define TMC5272_COOLCONF_SGT_FIELD(motor)                     ((RegisterField) { TMC5272_COOLCONF_SGT_MASK,  TMC5272_COOLCONF_SGT_SHIFT,  TMC5272_COOLCONF(motor), false })
#define TMC5272_COOLCONF_SFILT_MASK                           0x01000000
#define TMC5272_COOLCONF_SFILT_SHIFT                          24
#define TMC5272_COOLCONF_SFILT_FIELD(motor)                   ((RegisterField) { TMC5272_COOLCONF_SFILT_MASK,  TMC5272_COOLCONF_SFILT_SHIFT,  TMC5272_COOLCONF(motor), false })
#define TMC5272_DCCTRL_DC_TIME_MASK                           0x000003FF
#define TMC5272_DCCTRL_DC_TIME_SHIFT                          0
#define TMC5272_DCCTRL_DC_TIME_FIELD(motor)                   ((RegisterField) { TMC5272_DCCTRL_DC_TIME_MASK,  TMC5272_DCCTRL_DC_TIME_SHIFT,  TMC5272_DCCTRL(motor), false })
#define TMC5272_DCCTRL_DC_SG_MASK                             0x00FFFC00
#define TMC5272_DCCTRL_DC_SG_SHIFT                            10
#define TMC5272_DCCTRL_DC_SG_FIELD(motor)                     ((RegisterField) { TMC5272_DCCTRL_DC_SG_MASK,  TMC5272_DCCTRL_DC_SG_SHIFT,  TMC5272_DCCTRL(motor), false })
#define TMC5272_DRV_STATUS_SG_RESULT_MASK                     0x000003FF
#define TMC5272_DRV_STATUS_SG_RESULT_SHIFT                    0
#define TMC5272_DRV_STATUS_SG_RESULT_FIELD(motor)             ((RegisterField) { TMC5272_DRV_STATUS_SG_RESULT_MASK,  TMC5272_DRV_STATUS_SG_RESULT_SHIFT,  TMC5272_DRV_STATUS(motor), false })
#define TMC5272_DRV_STATUS_S2VSA_MASK                         0x00001000
#define TMC5272_DRV_STATUS_S2VSA_SHIFT                        12
#define TMC5272_DRV_STATUS_S2VSA_FIELD(motor)                 ((RegisterField) { TMC5272_DRV_STATUS_S2VSA_MASK,  TMC5272_DRV_STATUS_S2VSA_SHIFT,  TMC5272_DRV_STATUS(motor), false })
#define TMC5272_DRV_STATUS_S2VSB_MASK                         0x00002000
#define TMC5272_DRV_STATUS_S2VSB_SHIFT                        13
#define TMC5272_DRV_STATUS_S2VSB_FIELD(motor)                 ((RegisterField) { TMC5272_DRV_STATUS_S2VSB_MASK,  TMC5272_DRV_STATUS_S2VSB_SHIFT,  TMC5272_DRV_STATUS(motor), false })
#define TMC5272_DRV_STATUS_STEALTH_MASK                       0x00004000
#define TMC5272_DRV_STATUS_STEALTH_SHIFT                      14
#define TMC5272_DRV_STATUS_STEALTH_FIELD(motor)               ((RegisterField) { TMC5272_DRV_STATUS_STEALTH_MASK,  TMC5272_DRV_STATUS_STEALTH_SHIFT,  TMC5272_DRV_STATUS(motor), false })
#define TMC5272_DRV_STATUS_FSACTIVE_MASK                      0x00008000
#define TMC5272_DRV_STATUS_FSACTIVE_SHIFT                     15
#define TMC5272_DRV_STATUS_FSACTIVE_FIELD(motor)              ((RegisterField) { TMC5272_DRV_STATUS_FSACTIVE_MASK,  TMC5272_DRV_STATUS_FSACTIVE_SHIFT,  TMC5272_DRV_STATUS(motor), false })
#define TMC5272_DRV_STATUS_CS_ACTUAL_MASK                     0x001F0000
#define TMC5272_DRV_STATUS_CS_ACTUAL_SHIFT                    16
#define TMC5272_DRV_STATUS_CS_ACTUAL_FIELD(motor)             ((RegisterField) { TMC5272_DRV_STATUS_CS_ACTUAL_MASK,  TMC5272_DRV_STATUS_CS_ACTUAL_SHIFT,  TMC5272_DRV_STATUS(motor), false })
#define TMC5272_DRV_STATUS_STALLGUARD_MASK                    0x01000000
#define TMC5272_DRV_STATUS_STALLGUARD_SHIFT                   24
#define TMC5272_DRV_STATUS_STALLGUARD_FIELD(motor)            ((RegisterField) { TMC5272_DRV_STATUS_STALLGUARD_MASK,  TMC5272_DRV_STATUS_STALLGUARD_SHIFT,  TMC5272_DRV_STATUS(motor), false })
#define TMC5272_DRV_STATUS_OT_MASK                            0x02000000
#define TMC5272_DRV_STATUS_OT_SHIFT                           25
#define TMC5272_DRV_STATUS_OT_FIELD(motor)                    ((RegisterField) { TMC5272_DRV_STATUS_OT_MASK,  TMC5272_DRV_STATUS_OT_SHIFT,  TMC5272_DRV_STATUS(motor), false })
#define TMC5272_DRV_STATUS_OTPW_MASK                          0x04000000
#define TMC5272_DRV_STATUS_OTPW_SHIFT                         26
#define TMC5272_DRV_STATUS_OTPW_FIELD(motor)                  ((RegisterField) { TMC5272_DRV_STATUS_OTPW_MASK,  TMC5272_DRV_STATUS_OTPW_SHIFT,  TMC5272_DRV_STATUS(motor), false })
#define TMC5272_DRV_STATUS_S2GA_MASK                          0x08000000
#define TMC5272_DRV_STATUS_S2GA_SHIFT                         27
#define TMC5272_DRV_STATUS_S2GA_FIELD(motor)                  ((RegisterField) { TMC5272_DRV_STATUS_S2GA_MASK,  TMC5272_DRV_STATUS_S2GA_SHIFT,  TMC5272_DRV_STATUS(motor), false })
#define TMC5272_DRV_STATUS_S2GB_MASK                          0x10000000
#define TMC5272_DRV_STATUS_S2GB_SHIFT                         28
#define TMC5272_DRV_STATUS_S2GB_FIELD(motor)                  ((RegisterField) { TMC5272_DRV_STATUS_S2GB_MASK,  TMC5272_DRV_STATUS_S2GB_SHIFT,  TMC5272_DRV_STATUS(motor), false })
#define TMC5272_DRV_STATUS_OLA_MASK                           0x20000000
#define TMC5272_DRV_STATUS_OLA_SHIFT                          29
#define TMC5272_DRV_STATUS_OLA_FIELD(motor)                   ((RegisterField) { TMC5272_DRV_STATUS_OLA_MASK,  TMC5272_DRV_STATUS_OLA_SHIFT,  TMC5272_DRV_STATUS(motor), false })
#define TMC5272_DRV_STATUS_OLB_MASK                           0x40000000
#define TMC5272_DRV_STATUS_OLB_SHIFT                          30
#define TMC5272_DRV_STATUS_OLB_FIELD(motor)                   ((RegisterField) { TMC5272_DRV_STATUS_OLB_MASK,  TMC5272_DRV_STATUS_OLB_SHIFT,  TMC5272_DRV_STATUS(motor), false })
#define TMC5272_DRV_STATUS_STST_MASK                          0x80000000
#define TMC5272_DRV_STATUS_STST_SHIFT                         31
#define TMC5272_DRV_STATUS_STST_FIELD(motor)                  ((RegisterField) { TMC5272_DRV_STATUS_STST_MASK,  TMC5272_DRV_STATUS_STST_SHIFT,  TMC5272_DRV_STATUS(motor), false })
#define TMC5272_PWMCONF_PWM_OFS_MASK                          0x000000FF
#define TMC5272_PWMCONF_PWM_OFS_SHIFT                         0
#define TMC5272_PWMCONF_PWM_OFS_FIELD(motor)                  ((RegisterField) { TMC5272_PWMCONF_PWM_OFS_MASK,  TMC5272_PWMCONF_PWM_OFS_SHIFT,  TMC5272_PWMCONF(motor), false })
#define TMC5272_PWMCONF_PWM_GRAD_MASK                         0x0000FF00
#define TMC5272_PWMCONF_PWM_GRAD_SHIFT                        8
#define TMC5272_PWMCONF_PWM_GRAD_FIELD(motor)                 ((RegisterField) { TMC5272_PWMCONF_PWM_GRAD_MASK,  TMC5272_PWMCONF_PWM_GRAD_SHIFT,  TMC5272_PWMCONF(motor), false })
#define TMC5272_PWMCONF_PWM_FREQ_MASK                         0x00030000
#define TMC5272_PWMCONF_PWM_FREQ_SHIFT                        16
#define TMC5272_PWMCONF_PWM_FREQ_FIELD(motor)                 ((RegisterField) { TMC5272_PWMCONF_PWM_FREQ_MASK,  TMC5272_PWMCONF_PWM_FREQ_SHIFT,  TMC5272_PWMCONF(motor), false })
#define TMC5272_PWMCONF_PWM_AUTOSCALE_MASK                    0x00040000
#define TMC5272_PWMCONF_PWM_AUTOSCALE_SHIFT                   18
#define TMC5272_PWMCONF_PWM_AUTOSCALE_FIELD(motor)            ((RegisterField) { TMC5272_PWMCONF_PWM_AUTOSCALE_MASK,  TMC5272_PWMCONF_PWM_AUTOSCALE_SHIFT,  TMC5272_PWMCONF(motor), false })
#define TMC5272_PWMCONF_PWM_AUTOGRAD_MASK                     0x00080000
#define TMC5272_PWMCONF_PWM_AUTOGRAD_SHIFT                    19
#define TMC5272_PWMCONF_PWM_AUTOGRAD_FIELD(motor)             ((RegisterField) { TMC5272_PWMCONF_PWM_AUTOGRAD_MASK,  TMC5272_PWMCONF_PWM_AUTOGRAD_SHIFT,  TMC5272_PWMCONF(motor), false })
#define TMC5272_PWMCONF_FREEWHEEL_MASK                        0x00300000
#define TMC5272_PWMCONF_FREEWHEEL_SHIFT                       20
#define TMC5272_PWMCONF_FREEWHEEL_FIELD(motor)                ((RegisterField) { TMC5272_PWMCONF_FREEWHEEL_MASK,  TMC5272_PWMCONF_FREEWHEEL_SHIFT,  TMC5272_PWMCONF(motor), false })
#define TMC5272_PWMCONF_PWM_MEAS_SD_ENABLE_MASK               0x00400000
#define TMC5272_PWMCONF_PWM_MEAS_SD_ENABLE_SHIFT              22
#define TMC5272_PWMCONF_PWM_MEAS_SD_ENABLE_FIELD(motor)       ((RegisterField) { TMC5272_PWMCONF_PWM_MEAS_SD_ENABLE_MASK,  TMC5272_PWMCONF_PWM_MEAS_SD_ENABLE_SHIFT,  TMC5272_PWMCONF(motor), false })
#define TMC5272_PWMCONF_PWM_DIS_REG_STST_MASK                 0x00800000
#define TMC5272_PWMCONF_PWM_DIS_REG_STST_SHIFT                23
#define TMC5272_PWMCONF_PWM_DIS_REG_STST_FIELD(motor)         ((RegisterField) { TMC5272_PWMCONF_PWM_DIS_REG_STST_MASK,  TMC5272_PWMCONF_PWM_DIS_REG_STST_SHIFT,  TMC5272_PWMCONF(motor), false })
#define TMC5272_PWMCONF_PWM_REG_MASK                          0x0F000000
#define TMC5272_PWMCONF_PWM_REG_SHIFT                         24
#define TMC5272_PWMCONF_PWM_REG_FIELD(motor)                  ((RegisterField) { TMC5272_PWMCONF_PWM_REG_MASK,  TMC5272_PWMCONF_PWM_REG_SHIFT,  TMC5272_PWMCONF(motor), false })
#define TMC5272_PWMCONF_PWM_LIM_MASK                          0xF0000000
#define TMC5272_PWMCONF_PWM_LIM_SHIFT                         28
#define TMC5272_PWMCONF_PWM_LIM_FIELD(motor)                  ((RegisterField) { TMC5272_PWMCONF_PWM_LIM_MASK,  TMC5272_PWMCONF_PWM_LIM_SHIFT,  TMC5272_PWMCONF(motor), false })
#define TMC5272_PWM_SCALE_PWM_SCALE_SUM_MASK                  0x000003FF
#define TMC5272_PWM_SCALE_PWM_SCALE_SUM_SHIFT                 0
#define TMC5272_PWM_SCALE_PWM_SCALE_SUM_FIELD(motor)          ((RegisterField) { TMC5272_PWM_SCALE_PWM_SCALE_SUM_MASK,  TMC5272_PWM_SCALE_PWM_SCALE_SUM_SHIFT,  TMC5272_PWM_SCALE(motor), false })
#define TMC5272_PWM_SCALE_PWM_SCALE_AUTO_MASK                 0x01FF0000
#define TMC5272_PWM_SCALE_PWM_SCALE_AUTO_SHIFT                16
#define TMC5272_PWM_SCALE_PWM_SCALE_AUTO_FIELD(motor)         ((RegisterField) { TMC5272_PWM_SCALE_PWM_SCALE_AUTO_MASK,  TMC5272_PWM_SCALE_PWM_SCALE_AUTO_SHIFT,  TMC5272_PWM_SCALE(motor), false })
#define TMC5272_PWM_AUTO_PWM_OFS_AUTO_MASK                    0x000000FF
#define TMC5272_PWM_AUTO_PWM_OFS_AUTO_SHIFT                   0
#define TMC5272_PWM_AUTO_PWM_OFS_AUTO_FIELD(motor)            ((RegisterField) { TMC5272_PWM_AUTO_PWM_OFS_AUTO_MASK,  TMC5272_PWM_AUTO_PWM_OFS_AUTO_SHIFT,  TMC5272_PWM_AUTO(motor), false })
#define TMC5272_PWM_AUTO_PWM_GRAD_AUTO_MASK                   0x00FF0000
#define TMC5272_PWM_AUTO_PWM_GRAD_AUTO_SHIFT                  16
#define TMC5272_PWM_AUTO_PWM_GRAD_AUTO_FIELD(motor)           ((RegisterField) { TMC5272_PWM_AUTO_PWM_GRAD_AUTO_MASK,  TMC5272_PWM_AUTO_PWM_GRAD_AUTO_SHIFT,  TMC5272_PWM_AUTO(motor), false })
#define TMC5272_SG4_THRS_SG4_THRS_MASK                        0x000000FF
#define TMC5272_SG4_THRS_SG4_THRS_SHIFT                       0
#define TMC5272_SG4_THRS_SG4_THRS_FIELD(motor)                ((RegisterField) { TMC5272_SG4_THRS_SG4_THRS_MASK,  TMC5272_SG4_THRS_SG4_THRS_SHIFT,  TMC5272_SG4_THRS(motor), false })
#define TMC5272_SG4_THRS_SG4_FILT_EN_MASK                     0x00000100
#define TMC5272_SG4_THRS_SG4_FILT_EN_SHIFT                    8
#define TMC5272_SG4_THRS_SG4_FILT_EN_FIELD(motor)             ((RegisterField) { TMC5272_SG4_THRS_SG4_FILT_EN_MASK,  TMC5272_SG4_THRS_SG4_FILT_EN_SHIFT,  TMC5272_SG4_THRS(motor), false })
#define TMC5272_SG4_THRS_SG_ANGLE_OFFSET_MASK                 0x00000200
#define TMC5272_SG4_THRS_SG_ANGLE_OFFSET_SHIFT                9
#define TMC5272_SG4_THRS_SG_ANGLE_OFFSET_FIELD(motor)         ((RegisterField) { TMC5272_SG4_THRS_SG_ANGLE_OFFSET_MASK,  TMC5272_SG4_THRS_SG_ANGLE_OFFSET_SHIFT,  TMC5272_SG4_THRS(motor), false })
#define TMC5272_SG4_RESULT_SG_RESULT_MASK                     0x000003FF
#define TMC5272_SG4_RESULT_SG_RESULT_SHIFT                    0
#define TMC5272_SG4_RESULT_SG_RESULT_FIELD(motor)             ((RegisterField) { TMC5272_SG4_RESULT_SG_RESULT_MASK,  TMC5272_SG4_RESULT_SG_RESULT_SHIFT,  TMC5272_SG4_RESULT(motor), false })
#define TMC5272_SG4_IND_SG4_IND_0_MASK                        0x000000FF
#define TMC5272_SG4_IND_SG4_IND_0_SHIFT                       0
#define TMC5272_SG4_IND_SG4_IND_0_FIELD(motor)                ((RegisterField) { TMC5272_SG4_IND_SG4_IND_0_MASK,  TMC5272_SG4_IND_SG4_IND_0_SHIFT,  TMC5272_SG4_IND(motor), false })
#define TMC5272_SG4_IND_SG4_IND_1_MASK                        0x0000FF00
#define TMC5272_SG4_IND_SG4_IND_1_SHIFT                       8
#define TMC5272_SG4_IND_SG4_IND_1_FIELD(motor)                ((RegisterField) { TMC5272_SG4_IND_SG4_IND_1_MASK,  TMC5272_SG4_IND_SG4_IND_1_SHIFT,  TMC5272_SG4_IND(motor), false })
#define TMC5272_SG4_IND_SG4_IND_2_MASK                        0x00FF0000
#define TMC5272_SG4_IND_SG4_IND_2_SHIFT                       16
#define TMC5272_SG4_IND_SG4_IND_2_FIELD(motor)                ((RegisterField) { TMC5272_SG4_IND_SG4_IND_2_MASK,  TMC5272_SG4_IND_SG4_IND_2_SHIFT,  TMC5272_SG4_IND(motor), false })
#define TMC5272_SG4_IND_SG4_IND_3_MASK                        0xFF000000
#define TMC5272_SG4_IND_SG4_IND_3_SHIFT                       24
#define TMC5272_SG4_IND_SG4_IND_3_FIELD(motor)                ((RegisterField) { TMC5272_SG4_IND_SG4_IND_3_MASK,  TMC5272_SG4_IND_SG4_IND_3_SHIFT,  TMC5272_SG4_IND(motor), false })

Then the normal function for register read/write with SPI interface

void initAllMotors(uint16_t icID)
{
  // Set IREF_R2 and IREF_R3 to High for setting the REF resistor to 10k.
  // Run Current = 0.2A rms
  // Hold Current = 0.14A rms
  // Chopper Mode = SpreadCycle

  // For Motor 0 & 1
  tmc5272_writeRegister(icID, TMC5272_GCONF, 0x10024002);  // writing value 0x10024002 = 268582914 = 0.0 to address 0 = 0x00(GCONF)
  tmc5272_writeRegister(icID, TMC5272_DRV_CONF, 0x0000034D);  // writing value 0x0000034D = 845 = 0.0 to address 3 = 0x05(DRV_CONF)
  tmc5272_writeRegister(icID, TMC5272_GLOBAL_SCALER, 0xFBFBFBFB); 		// writing value 0xFBFBFBFB = 0 = 0.0 to address 4 = 0x06(GLOBAL_SCALER)

  // For Motor 0
  tmc5272_writeRegister(icID, TMC5272_IHOLD_IRUN(0), 0x04010F0A);  // writing value 0x04011F0A = 67182346 = 0.0 to address 10 = 0x12(M0_IHOLD_IRUN)
  tmc5272_writeRegister(icID, TMC5272_CHOPCONF(0), 0x10410153);  // writing value 0x10410153 = 272695635 = 0.0 to address 39 = 0x38(M0_CHOPCONF)
  tmc5272_writeRegister(icID, TMC5272_AMAX(0), 51200);  // writing value to address 21 = 0x20(M0_AMAX)

  // For Motor 1
  tmc5272_writeRegister(icID, TMC5272_IHOLD_IRUN(1), 0x04010F0A);  // writing value 0x04011F0A = 67182346 = 0.0 to address 10 = 0x12(M0_IHOLD_IRUN)
  tmc5272_writeRegister(icID, TMC5272_CHOPCONF(1), 0x10410153);  // writing value 0x10410153 = 272695635 = 0.0 to address 39 = 0x38(M0_CHOPCONF)
  tmc5272_writeRegister(icID, TMC5272_AMAX(1), 51200);  // writing value to address 21 = 0x20(M0_AMAX)

  // Enable Motor 0 & 1
  tmc5272_writeRegister(icID, TMC5272_GCONF, 0x00020002);  // writing value 0x00020002 = 131074 = 0.0 to address 0 = 0x00(GCONF)
}

4 Coding

Here is the code put the stepper motor in velocity mode

#define IC_ID 0
static TMC5272BusType activeBus = IC_BUS_SPI;
static uint8_t nodeAddress = 0;

const uint8_t tmcCRCTable_Poly7Reflected[256] = {
    0x00, 0x91, 0xE3, 0x72, 0x07, 0x96, 0xE4, 0x75, 0x0E, 0x9F, 0xED, 0x7C, 0x09, 0x98, 0xEA, 0x7B,
    0x1C, 0x8D, 0xFF, 0x6E, 0x1B, 0x8A, 0xF8, 0x69, 0x12, 0x83, 0xF1, 0x60, 0x15, 0x84, 0xF6, 0x67,
    0x38, 0xA9, 0xDB, 0x4A, 0x3F, 0xAE, 0xDC, 0x4D, 0x36, 0xA7, 0xD5, 0x44, 0x31, 0xA0, 0xD2, 0x43,
    0x24, 0xB5, 0xC7, 0x56, 0x23, 0xB2, 0xC0, 0x51, 0x2A, 0xBB, 0xC9, 0x58, 0x2D, 0xBC, 0xCE, 0x5F,
    0x70, 0xE1, 0x93, 0x02, 0x77, 0xE6, 0x94, 0x05, 0x7E, 0xEF, 0x9D, 0x0C, 0x79, 0xE8, 0x9A, 0x0B,
    0x6C, 0xFD, 0x8F, 0x1E, 0x6B, 0xFA, 0x88, 0x19, 0x62, 0xF3, 0x81, 0x10, 0x65, 0xF4, 0x86, 0x17,
    0x48, 0xD9, 0xAB, 0x3A, 0x4F, 0xDE, 0xAC, 0x3D, 0x46, 0xD7, 0xA5, 0x34, 0x41, 0xD0, 0xA2, 0x33,
    0x54, 0xC5, 0xB7, 0x26, 0x53, 0xC2, 0xB0, 0x21, 0x5A, 0xCB, 0xB9, 0x28, 0x5D, 0xCC, 0xBE, 0x2F,
    0xE0, 0x71, 0x03, 0x92, 0xE7, 0x76, 0x04, 0x95, 0xEE, 0x7F, 0x0D, 0x9C, 0xE9, 0x78, 0x0A, 0x9B,
    0xFC, 0x6D, 0x1F, 0x8E, 0xFB, 0x6A, 0x18, 0x89, 0xF2, 0x63, 0x11, 0x80, 0xF5, 0x64, 0x16, 0x87,
    0xD8, 0x49, 0x3B, 0xAA, 0xDF, 0x4E, 0x3C, 0xAD, 0xD6, 0x47, 0x35, 0xA4, 0xD1, 0x40, 0x32, 0xA3,
    0xC4, 0x55, 0x27, 0xB6, 0xC3, 0x52, 0x20, 0xB1, 0xCA, 0x5B, 0x29, 0xB8, 0xCD, 0x5C, 0x2E, 0xBF,
    0x90, 0x01, 0x73, 0xE2, 0x97, 0x06, 0x74, 0xE5, 0x9E, 0x0F, 0x7D, 0xEC, 0x99, 0x08, 0x7A, 0xEB,
    0x8C, 0x1D, 0x6F, 0xFE, 0x8B, 0x1A, 0x68, 0xF9, 0x82, 0x13, 0x61, 0xF0, 0x85, 0x14, 0x66, 0xF7,
    0xA8, 0x39, 0x4B, 0xDA, 0xAF, 0x3E, 0x4C, 0xDD, 0xA6, 0x37, 0x45, 0xD4, 0xA1, 0x30, 0x42, 0xD3,
    0xB4, 0x25, 0x57, 0xC6, 0xB3, 0x22, 0x50, 0xC1, 0xBA, 0x2B, 0x59, 0xC8, 0xBD, 0x2C, 0x5E, 0xCF,
};

int nSleep = 23;
int iRefR2 = 27;
int iRefR3 = 29;
int uartMode = 31;

uint8_t tmc5272_getNodeAddress(uint16_t icID) {
  return nodeAddress;
}

TMC5272BusType tmc5272_getBusType(uint16_t icID) {
  return activeBus;
}

void tmc5272_readWriteSPI(uint16_t icID, uint8_t *data, size_t dataLength) {
  digitalWrite(PIN_SPI_SS, LOW);
  delayMicroseconds(10);

  for (uint32_t i = 0; i < dataLength; i++) {
    data[i] = SPI.transfer(data[i]);
    Serial.println(data[i]);
  }

  delayMicroseconds(10);
  digitalWrite(PIN_SPI_SS, HIGH);
}


void setup() {
  Serial.begin(115200);

  // put your setup code here, to run once:
  pinMode(PIN_SPI_SS, OUTPUT);
  pinMode(nSleep, OUTPUT);
  pinMode(iRefR2, OUTPUT);
  pinMode(iRefR3, OUTPUT);
  pinMode(uartMode, OUTPUT);

  digitalWrite(PIN_SPI_SS, HIGH);
  digitalWrite(nSleep, LOW); // Disabling standby
  digitalWrite(iRefR2, LOW);
  digitalWrite(iRefR3, LOW);

  if (activeBus == IC_BUS_SPI) {
    digitalWrite(uartMode, LOW);

    SPI.begin();
    SPI.beginTransaction(SPISettings(500000, MSBFIRST, SPI_MODE3));
  } else if (activeBus == IC_BUS_UART) {
    digitalWrite(uartMode, HIGH);
    //Serial3.begin(115200);
    pinMode(PIN_SPI_MOSI, OUTPUT);
    pinMode(PIN_SPI_SCK, OUTPUT);
    digitalWrite(PIN_SPI_MOSI, LOW);
    digitalWrite(PIN_SPI_SS, LOW);
    digitalWrite(PIN_SPI_SCK, LOW);
  }

  delay(10);

  digitalWrite(iRefR2, HIGH);
  digitalWrite(iRefR3, HIGH);

  initAllMotors(IC_ID);
  tmc5272_rotateMotor(IC_ID, 0, 0x00002710);
  tmc5272_rotateMotor(IC_ID, 1, 0x00002710);
}

void loop() {
  int32_t value = tmc5272_readRegister(IC_ID, TMC5272_VMAX(0));
  Serial.print("Received Data: ");
  Serial.println(value);
  Serial.print(" from register: ");
  Serial.println(TMC5272_VMAX(0), HEX);
  delay(1000);
}

Build and download the code

The motor turns in one direction in setting velocity,

5 Summary

The MKR board can work with range detect sensors and control the stepper motor as same time. Then build the rover platform for this project.

ASM - 3D Printing and Assembly

taifur — Wed, 01 Jan 2025 18:29:50 GMT

For controlling a sewing machine a foot pedal is used. As I want to control the foot pedal using stepper motor I developed a 3D printed vertical mechanism for pressing the foot pedal down based on the finger bending. I used the following components for the mechanism.

I designed and 3D printed the following parts. The .stl design files are attached in the attachment section. The left top is the stepper mount, the left bottom is the armature and the right big part is the base.

The following image shows the assembly of the stepper mount with the base using 4 M3x15 screws.

The assembly of the armature with the threaded rod and screw is shown in the following images.

The following photo shows installing the linear rail that helps to smoothly guide the armature vertically up and down.

The complete assembled pressing mechanism is shown in the following images.

Watch the working video below:

community.element14.com/.../Pressing-Mechanism1.mp4

community.element14.com/.../Pressing-Mechanism2.mp4

Attachment (3D stl files):

community.element14.com/.../Accessible-Sewing-Machine-Armature.stl

community.element14.com/.../Accessible-Sewing-Machine-Base.stl

community.element14.com/.../Accessible-Sewing-Machine-Bracket.stl

Smart Conveyor Belt for Sorting System - Blog Series and Project Write-Up

meera_hussien — Tue, 31 Dec 2024 04:28:04 GMT

Project Title: Smart Conveyor Belt for Sorting System

Project Overview

The Smart Conveyor Belt for Sorting System is an innovative prototype designed to automate sorting tasks using sensors, stepper motors, and IoT integration. This small-scale project replicates industrial conveyor belt systems and aims to demonstrate how automation can simplify sorting processes in various sectors such as agriculture, e-commerce, and manufacturing.

By utilizing 3D printing technology, the project showcases a modular design that can be easily replicated or scaled. The system uses IR sensors to detect objects on the conveyor and servos to divert them into designated bins. The project integrates IoT to monitor and control operations remotely, enhancing efficiency and adaptability.

Key Objectives

Design and fabricate a conveyor belt system driven by a NEMA 17 stepper motor.
Implement object detection and sorting through IR sensors and servo motors.
Develop an IoT dashboard using ThingsBoard for real-time monitoring and data visualization.
Utilize FreeCAD to design and 3D print the conveyor frame and components.

Features and Highlights

Compact Design: A conveyor belt with modular, 3D-printed parts.
Smart Sorting: Servo-driven arms that sort objects based on sensor feedback.
IoT Integration: Remote monitoring and control through ThingsBoard.
Scalability: Easily expandable for larger applications or adapted for specific sorting needs.

Project Timeline

Blog 1: Getting Started with the Smart Conveyor Belt Project: Design and Planning
Blog 2: 3D Printing the Conveyor Frame and Components
Blog 3: Wiring and Motor Control: Bringing the Conveyor to Life
Blog 4: Building the Sorting Mechanism: Servo Arms and Object Detection
Blog 5: IoT Integration and Remote Monitoring for Smart Sorting
Final Write-Up: Comprehensive project documentation and code repository

Why This Project Matters

Automation is at the forefront of modern industries, and learning how to build and implement automated systems provides valuable hands-on experience. This project not only enhances technical skills in CAD design, motor control, and IoT but also offers insight into real-world applications of conveyor systems.

Stay tuned as each blog dives into a different phase of the project, bringing the Smart Conveyor Belt System to life step by step.

RangeDetect Rover 2# Range Detector Sensors

fyaocn — Tue, 31 Dec 2024 02:52:27 GMT

2# Range Detector Sensors

1 Introduction
2 TMC5272-EVAL-KIT and TRINAMIC stepper motor
3 TMCL-IDE
4 Drive the stepper motor and Next to do

1 Introduction

There are two types of sensors used in range detecting. Ultrasonic sensor HC-SR04 and 60GHz mmWare radar sensor.

The HC-SR04 ultrasonic sensor uses sonar to determine the distance to an object. This sensor reads from 2cm to 400cm (0.8inch to 157inch) with an accuracy of 0.3cm (0.1inches). This is used for near range detection.

60GHz mmWave Sensor - Human Resting Breathing and Heartbeat Module has been updated, adding sleep monitoring function. This can detect range of 2000cm with smart algorithm with human detection.

2 HC-SR04

The HC-SR04 ultrasonic sensor is widely used with Power Supply :+5V DC, the Effectual Angle: <15° and normally Ranging Distance : 2cm – 400 cm/1″ – 13ft

There are arduino library implements the algorithm, so I use MKR wifi 1010 as host MCU for this sensor. Here is the code

#include <afstandssensor.h>
AfstandsSensor afstandssensor(7, 6);  

void setup () {
    Serial.begin(9600);  
}

void loop () {
    Serial.println(afstandssensor.afstandCM());
    delay(500);
}

The distance is output in centimeter

In this project the sensor is used.

3 60GHz mmWare radar sensor

The MR60BHA1 60GHz mmWave Static Breathing and Heartbeat radar module applies FMCW detected theory to implement simultaneous personal breathing rate and heart rate detention in high accuracy, providing a fully total private and secure environment, independently from other noisy influences. It is a standard biotic radar system in consumer electronics, healthcare as well as industrial applications.

Frequency Modulated Continuous Wave (FMCW) Radar is a special type of radar sensor which radiates continuous transmission power like a simple continuous-wave radar. Instead of using the time to measure distance (like TOF), FMCW technology emits a radar signal with a frequency that increases continuously to create a signal sweep. After being reflected by the process media surface, the signal’s echo will be picked up by the antenna. As the emitted signal is constantly varying in frequency, there is a slight difference between the frequencies of the echo and the emitted signals. This difference in frequency is directly proportional to the echo delay, thus allowing the accurate measurement of distances.

Here is arduino code

#include "Arduino.h"
#include <60ghzbreathheart.h>

//#include <SoftwareSerial.h>
// Choose any two pins that can be used with SoftwareSerial to RX & TX
//#define RX_Pin A2
//#define TX_Pin A3

//SoftwareSerial mySerial = SoftwareSerial(RX_Pin, TX_Pin);

// we'll be using software serial
//BreathHeart_60GHz radar = BreathHeart_60GHz(&mySerial);

// can also try hardware serial with
BreathHeart_60GHz radar = BreathHeart_60GHz(&Serial1);

void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
  Serial1.begin(115200);

  //  mySerial.begin(115200);

  while(!Serial);   //When the serial port is opened, the program starts to execute.

  Serial.println("Ready");
}

void loop()
{
  // put your main code here, to run repeatedly:
  radar.HumanExis_Func();           //Human existence information output
  if(radar.sensor_report != 0x00){
    switch(radar.sensor_report){
      case NOONE:
        Serial.println("Nobody here.");
        Serial.println("----------------------------");
        break;
      case SOMEONE:
        Serial.println("Someone is here.");
        Serial.println("----------------------------");
        break;
      case NONEPSE:
        Serial.println("No human activity messages.");
        Serial.println("----------------------------");
        break;
      case STATION:
        Serial.println("Someone stop");
        Serial.println("----------------------------");
        break;
      case MOVE:
        Serial.println("Someone moving");
        Serial.println("----------------------------");
        break;
      case BODYVAL:
        Serial.print("The parameters of human body signs are: ");
        Serial.println(radar.bodysign_val, DEC);
        Serial.println("----------------------------");
        break;
      case DISVAL:
        Serial.print("The sensor judges the distance to the human body to be: ");
        Serial.print(radar.distance, DEC);
        Serial.println(" m");
        Serial.println("----------------------------");
        break;
      case DIREVAL:
        Serial.print("The sensor judges the orientation data with the human body as -- x: ");
        Serial.print(radar.Dir_x);
        Serial.print(" m, y: ");
        Serial.print(radar.Dir_y);
        Serial.print(" m, z: ");
        Serial.print(radar.Dir_z);
        Serial.println(" m");
        Serial.println("----------------------------");
        break;
    }
  }
  delay(200);                       //Add time delay to avoid program jam
}

With the output

The distance to human and angle can be got to get precise position for range detection.

4 Sensor fusion and range detection

Another effort on combining the sensor data to get precise environment sensing capability and deploy AI model to get result is called sensor fusion. It would be interesting to find out how it can work in this project.

Thread Tapping System (Start a Movement Design Challenge))

dougw — Tue, 31 Dec 2024 02:49:15 GMT

Intro

This is a quick update in the Start a Movement Design Challenge to demonstrate the assembled thread tapping system with both stepper motors running.

The 6-32 tap that is in the chuck requires the lead screw to provide 1 inch of forward travel, for every 32 rotations of the tap bit.

Video - Assembled Thread Tapping System With Motors Running

https://youtu.be/9b9TPG0zXng

Discussion

The hardware for the thread tapping machine is now complete and working very well. The Analog Devices Trinamic stepper motor control system provides micro stepping control which allows the linear actuator to be precisely synchronized to the rotary actuator so that any tap can be accommodated. I am still at a loss as to how to get the system to use more than 30 mA, but the planetary gearbox provides so much torque multiplication, not much current is needed.

AVR Part 1 - The Concept

Gough Lui — Tue, 31 Dec 2024 00:58:30 GMT

Welcome to my first project post. My project is called "AVR" and that's not named after the 8-bit microcontroller!

Why "Start a Movement"?

I decided to participate in this design challenge for a few reasons. The first was simply because it looked interesting as it involved stepper motors, something I've always wanted to employ in my own projects but never had the chance to. Such motors are great for making precise movements, being the driving force (quite literally) behind the positioning of heads in early hard drives and floppy drives, through to your humble dot-matrix printer, some CNC milling machines and even modern 3D printers. They're definitely something which can be very useful for open-loop control as well, saving the complexity of feedback control.

The next reason was simply because there seemed to be a few calls for competitors, suggesting there was a good chance to snag a kit. The prizes looked good too - I'm a big fan of eMobility solutions and I think they're a vital part of a decarbonised future.

But perhaps most importantly, I had a problem that I wanted to solve inexpensively. This is one that has been bugging me for many years and is something that you could theoretically buy your way out of, given enough money. But I didn't have that kind of money to spare.

The Problem and Concept

If you want a regulated DC power supply, you'd just grab a lab benchtop power supply or a plug-pack or perhaps even USB/USB-C PD and you'd be set. This is such a bread-and-butter requirement that we have a bread-and-butter solution to it.

But if you want a regulated AC mains power supply, then that's a whole different kettle of fish. Your wall-socket nominal 115/230V is never quite exactly that, as loads inside the house and loads along your street can change the voltage at any time. This is simply down to how resistance in the transmission lines cause voltage drop as a function of current flow (ohms law). Aside from that, the distribution network often has tap changing transformers which can boost or buck by fixed ratios to try and bring the voltages within a band, as loads can change significantly throughout the day. For example, this is a graph I previously made of line voltage in my house across a 24 hour period:

What is nominally 230V has quite a spread. But when testing certain sorts of appliances, the voltage has a direct bearing on energy consumption, so testing with a voltage that varies would be unfair. The IEC62301 standard that has to do with standby energy qualification, for example, sets stringent voltage requirements of +/-1% of nominal for accurate testing. As a result, ordinary mains power simply cannot do (and it likely can't for other reasons, including crest factor, but we can't do much about that in this challenge).

So, I called this project "AVR", short for "Automatic Voltage Regulator". The idea would be that by taking an autotransformer (e.g. a Variac) that allows for nearly-continuous output voltage control and connecting its mechanical input shaft in such a way that it can be computer controlled, we could "close the loop" on the system by using the readings from a power analyser (e.g. the Tektronix PA1000 I previously RoadTested) in order to counteract slow mains voltage movements (e.g. up to 2 adjustments per second) and keep the output voltage within a set band, hopefully rapid enough to take out most of the influence of grid voltage variation). This is not going to help if the mains voltage has a "step" change (e.g. due to tap changer operation) but the closer to the target voltage it is, the less likely such disturbances will push the output voltage out of band. In essence, we'd be trying to keep the voltage at the set-point all the time, similar to how someone would move around to keep a basketball balanced on their finger. It probably won't be able to guarantee a +/- 1% result, but it should mean that I can run my longer mains-powered appliance tests more comfortably with less "noise" in the readings.

For this, we need a Variac and thankfully, I have not one but two small ones. The one I will be using for this challenge is a Yamabishi Electric (Japanese) unit I wrote about here: A Shocking Variac Made a Little Less Shocking!

My plan would be to take the knob off of the unit, design a 3D printed coupling that might take a trio of M3 screws as grub screws on both sides to couple the shafts together, all with an adapter plate that keeps the alignment of the motor and Variac body constant. Then, using the provided driver and evaluation board, I'd figure out how to get it hooked up to the computer, under computer control (USB would be fine) whereby a script could then poll my PA1000 power analyser and set appropriate adjustments on the Variac, making decisions at every step as to whether to move it or not (as the carbon brush is something that will wear down quickly if excessive unnecessary adjustments are made).

You might be thinking "Well, hold on a minute. Don't those newfangled UPSes have AVRs in them?" and you'd be right. Many line-interactive UPSes advertise the presence of AVR functionality. However, their form of AVR is made with discrete windings on a transformer, thus allowing you to "boost" or "buck" the input by a fixed percentage increment, usually something between 5-10%, causing a massive jump every time it happens. For precision AC applications, this is not ideal.

Another thought may be "Why not just use a DC to AC true sine-wave inverter as a source? They're stable, right?" and this is something I'm already doing. However, what they don't tell you is that the inverters have some higher frequency harmonic content and insufficient regulation to deal with high crest-factor loads which leads to noticeable load-modulation of the voltage. Another issue I'm also finding is that the voltages from such inverters also jump, due to temperature changes within the board and compensation for that, which are a pain whenever the inverter is not on a constant load (as every heat-up and cool-down cycle, especially with thermostatic fan) results in a voltage jump. They also seem to have an offset from the factory (230V nominal is often measured at 233V or 235V) which necessitates trimming and their limited reactive power capabilities seem to cause my power analyser to give very inaccurate power-factor readings.

Getting nice, regulated, powerful AC is something that, ideally, you should be using a synthetic mains AC source (such as these behemoths from GWInstek or Keysight) for. My pockets aren't quite so deep though ... so I'm going to try and be clever.

Conclusion

In this post, I've summarised my motivations for "starting a movement" and the project I intend to build. The whole concept of the "AVR" is to regulate mains AC voltage by allowing a mechanical autotransformer to be computer-controlled, which, when paired with a power analyser can allow for "closing the loop" forming a feedback control system that can serve to regulate the output voltage to a load within a set band on a nearly continuous basis without the jumps ordinarily associated with UPS-based AVR systems.

In the next posting, I'll be unboxing the kit and looking at its components.

P.S.

I'd like to apologise as this is an exceptionally late start to a design challenge and one that I am feeling like I am unlikely to complete. It has been about a month that I've been battling a sudden decline in my health, losing most of my central vision in one eye and losing mobility with one or both of my ankles on an on-and-off basis suffering from severe pain. This makes it a literal pain to do almost anything and really sapped away some of my motivation. Concurrently with this design challenge, I had also a period of triple-concurrent RoadTests (of which two still are in-progress), which put immense strain on the time and energy I had left.

I'm not looking for sympathy - just hoping to ensure that the community is not left empty-handed and to show that I've decided to give it a go nonetheless. While I will recover in time, it is not expected to be a quick road to recovery, expecting to take six or so months. As a result, I am intending to curtail future involvement in element14 programs until I am confident of my ability to deliver, as some of this is stress-related (likely imposed from both work and hobby). In the meantime, best of luck to my fellow challengers and I would appreciate if you would support their efforts.

Wireless camera

amgalbu — Mon, 30 Dec 2024 11:38:57 GMT

The housing for the wireless camera is ready!

The case is a slightly modified version of the project available on thingverse (https://www.thingiverse.com/thing:2254307)

The camera runs a MJPEG streamer. In this post you can find all the details

Here are some pictures of the camera

RangeDetect Rover 1# Unboxing and Roadtest to TMC5272-EVAL-KIT and TRINAMIC stepper motor

fyaocn — Mon, 30 Dec 2024 03:36:31 GMT

1# Roadtest to TMC5272-EVAL-KIT and TRINAMIC stepper motor

1 Introduction
2 TMC5272-EVAL-KIT and TRINAMIC stepper motor
3 TMCL-IDE
4 Drive the stepper motor and Next to do

1 Introduction

The TMC5272 is a Step/Dir Driver for Two-Phase Bipolar Stepper Motors up to 0.8 A (RMS) (1.12 A (PEAK)). TMC5272-EVAL-KIT and Landungsbruecke with with bridge Board can run with TMCL-IDE to rest the performance and function of the TMC5272. One RINAMIC Stepper Motor, Single Shaft, Hybrid, 42 mm, Bipolar, 1.8 °, 27 N-cm, 1 A is used as stepper motor in this road test.

Refer to TMC5272-EVAL Evaluation Board | Analog Devices and LANDUNGSBRUECKE Evaluation Board | Analog Devices for more details.

2 TMC5272-EVAL-KIT and TRINAMIC stepper motor

The TMC5272-EVAL allows evaluation of the TMC5272 in combination with the ADI TRINAMIC evaluation board system, or as a stand-alone board. It uses the standard schematic and offers several options in order to test different modes of operation. The TMC5272 is a Step/Dir Driver for Two-Phase Bipolar Stepper Motors up to 0.8 A RMS (1.5 A peak). The board is full functions with high performance and easy control. With features as,
CoolStep™
Passive Braking
Short Detection
Slope Control
StallGuard2™
MicroPlyer™
DcStep™
Position Mode
Velocity Mode
Dual Encoder
2x 2-phase stepper motor up to 0.8 A (RMS) coil current (1.12 A (PEAK))
Supply Voltage 2.1 to 20 V DC
SPI and Single Wire UART
Encoder Interface with alt. functions
1 to 256 microsteps
StealthChop2 silent PWM mode
StallGuard4 sensorless motor load detection
TriCoder Sensorless Standstill Steploss Detection and Full Step Encoder

There functions are good for smooth and precise control for high end tasks in industrial, medical and consumer products.

And this the parameter and function for this stepper motor.

3 TMCL-IDE

TMCL-IDE is best used in this road test and help understanding the how the above features works. The hardware is configurated below, one pink clipper on the shaft can show how the stepper motor runs.

This the short video for the stepper motor in velocity mode,

Start the TMCL-IDE,

if the board is not automatic recognized, manually select it. or it is in direct mode only

The board connect the TMIC-IDE in serial port, all function is opened for roadtest,

Here is settings, the drive board is unknown, so manually selected as well.

update the firmware for driver board first,

wait until if completed successfully.

All the function can be control and traced in registers,

Functions in GUI for easy control

IN direct mode, the registers are read or write directly for fast control

Now connect and plug 12V DC power, the ADC readings show the input voltages and some info.

adjust the reference current setting to make the calibration button green. In this case the settings is 0.1A

The feedback current sensing shows 0.1A as well,

For advance control in coolsteps and stallGuard

Square PWM waveform is normally used, and it can be configurated in sinus mode as this part shows,

The stepper motor can be controlled in position mode or velocity mode, 256 steps per round and the position is defined in steps

Here is the control GUI

this is velocity mode GUI

The velocity can be controlled as smooth as it can be , change the number or simple pull the virtual button, feel how the TMC5272 drive the stepper motors.

4 Drive the stepper motor and Next to do

This roadtest is easy and pleasant, try the TMCL-IDE with reading the reference manual. High performance of TMC5272 can easily be found out. My proposal is drive the rover with stepper motor, in fact , it can be more fit for precise control in millimeters or even smaller. Next step shall be build the rover and setting the range detect sensors.

DIY Pick N Place - Vision Recognition

RParkerE — Sun, 29 Dec 2024 06:50:32 GMT

Building a Robust PCB Component Detection System with Jetson AI

I am excited to share my latest progress on the DIY Pick N Place project! After several iterations of testing and refinement, I've developed a robust computer vision system capable of detecting and verifying PCB components using NVIDIA's Jetson platform.

Key Features

My system now includes:

Dual-mode operation supporting both live camera feed and test images
Robust component detection using SSD-MobileNet v2
Template matching for placement verification
Comprehensive error handling and validation
Built-in support for testing and validation

Technical Implementation

The system is built around a Python class called PCBVisionSystem that handles all aspects of the detection pipeline. I've implemented several key improvements:

First, I added flexible input handling that supports both live camera feeds and test images. This makes it much easier to develop and validate the system using a set of reference PCBs before deploying it in production.

The component detection pipeline uses NVIDIA's optimized deep learning libraries through the Jetson inference API. I am using an SSD-MobileNet v2 model that's been trained to recognize various PCB components including header pins, SMD pads, and IC footprints.

For placement verification, I've implemented a template matching system that compares detected components against reference images. This helps ensure that components are not only detected but correctly oriented and placed.

Usage

The system can be run in two modes:

# Live camera mode
python pcb_vision.py

# Test image mode
python pcb_vision.py --test-image path/to/image.jpg

# Process specific number of frames
python pcb_vision.py --max-frames 100

Next Steps

While the system is now functionally complete, there are several areas I am looking to enhance:

Expanding the component template library
Adding support for component measurement and tolerance checking
Integrating with robotic placement systems

Testing Guidelines

To test the system with your own PCB images:

Create a templates directory and add reference images for your components
Prepare a set of test PCB images
Run the system in test mode with your images
Check the detection results and verification scores

CodeBin of Python Code

Connector Tester Hardware / Software Demo

dougw — Sun, 29 Dec 2024 01:06:06 GMT

Intro

This update to the Connector Tester portion of my "Start a Movement" design challenge project covers the completed hardware and software for this machine. Just to recap, the connector tester cycles a connector mating pair open and closed while checking for faults such as open or short circuits on each pin. Such testers are used to determine how many mating cycles any particular connector will typically survive. It can also test cable integrity, but that only needs one mating cycle.

Video - Connector Tester Hardware Demo

https://youtu.be/8qYTc6NIxII

I just noticed the video did not show that there is an adjustment for the mating connector to lock down precise alignment.

3D Printed Parts

The connector tester machine has five 3D printed parts held together with at least 55 screws. There are no nuts except the leadscrew Acme nut, so many holes had to be threaded.

https://youtu.be/TKpQ3uVUtm4

Discussion

The connector tester hardware and Mega firmware are working great. The parts fit precisely and the test software works well. Unfortunately I lost the magic of how to set up the motor current and cannot get it set up properly in the TMCL-IDE.

The IDE does a good job of running the repetitive position based cycle I want, but for some reason the full current I set up does not get applied to the motor. Incredibly frustrating after all the meticulous design work that went into the this machine..

This will also be an issue for the thread tapping machine if I can't solve it.

The fixed plastic connector mount is a bit marginal in stiffness - it does flex a bit under the full mating force, but it still works fine. A real production machine would use metal parts for durability and stiffness.

I initially had this problem, but the system suddenly started to supply the proper current. Then the next day when I came back to shoot video, I could no longer get the required current.

Controlling Stepper Based on Flex Sensor

taifur — Fri, 27 Dec 2024 12:57:14 GMT

I want to use a Flex sensor to control the stepper motor based on the bending of the finger. A flex sensor is a low-cost, easy-to-use variable resistor that is designed to measure the amount of deflection it experiences when bent. The sensor's resistance is lowest when it's straight or flat on the surface, increases when we bend it slowly and reaches its maximum when it's at a 90-degree angle. Due to it's size a flex sensor can be easily attached with the finger to measure the bending of the finger.

As already said, a flex sensor is a variable resistor that varies its resistance upon bending. As the resistance of the sensor is directly proportional to the amount of bending, it's often called Flexible potentiometer. This sensor is commonly available in two sizes, the first is 2.2” and the second one is 4.5” long. I am using the 2.2 inch flex for my project. When the sensor is straight the resistance is about 25K, and when the sensor is bent the value is 69K. As flex sensor is a resistor we must convert the resistance to voltage to read it using MCU. To get a proportional voltage to the sensor we need to make a voltage divider circuit attaching a fixed resistor in series with the sensor as shown in the animated image below. Based on the bending the resistance of the sensor changes and the output voltage also changes accordingly.

The image was taken from circuitdigest.com

The sensitivity of the sensor depends on the value of the fixed resistor connected with the flex sensor. For calculating the exact value for maximum sensitivity first I measured the resistance of the sensor when it is straight and when it is bent at 90 degree. Then I calculate the resistance for getting the maximum variation in the output volage using Microsoft Excel.

I got the maximum sensitivity for the resistance of 41.5K. So, I planned to placed a 50K trim pot and set it to 41.5K and then connect it in series with the Flex sensor to get the maximum sensitivity. But for testing I connected one 20K and one 22K resistor in series for getting an approximate output. I used the following code for running the motor based on the bending.

/*******************************************************************************
* Copyright © 2023 Analog Devices Inc. All Rights Reserved.
* This software is proprietary to Analog Devices, Inc. and its licensors.
*******************************************************************************/

#include <SPI.h>

extern "C" {
#include "TMC5272_register_map.h"
#include "tmc5272.h"

}

/* 
 * Arduino Pins   Eval Board Pins
 * 51 MOSI        32 SPI1_SDI
 * 50 MISO        33 SPI1_SDO
 * 52 SCK         31 SPI1_SCK
 * 53 SS          30 SPI1_CSN
 * GND            23 CLK16 -> use internal 
 * 23 DIO         19 nSleep 
 * GND            2 GND
 * +5V            5 +5V_USB
 * 27 iRefR2      35 IREF_R2
 * 29 iRefR3      36 IRREF_R3
 * 31 uartMode    20 USEL/ for uart mode it should be HIGH
 */

#define IC_ID 0

int nSleep = 23;
int iRefR2 = 27;
int iRefR3 = 29;
int uartMode = 31;

void tmc5272_readWriteSPI(uint16_t icID, uint8_t *data, size_t dataLength) {
  digitalWrite(PIN_SPI_SS, LOW);
  delayMicroseconds(10);

  for (uint32_t i = 0; i < dataLength; i++) {
    data[i] = SPI.transfer(data[i]);
    Serial.println(data[i]);
  }

  delayMicroseconds(10);
  digitalWrite(PIN_SPI_SS, HIGH);
}
int previous_value;
void setup() {
  Serial.begin(115200);

  // put your setup code here, to run once:
  pinMode(PIN_SPI_SS, OUTPUT);
  pinMode(nSleep, OUTPUT);
  pinMode(iRefR2, OUTPUT);
  pinMode(iRefR3, OUTPUT);
  pinMode(uartMode, OUTPUT);

  digitalWrite(PIN_SPI_SS, HIGH);
  digitalWrite(nSleep, LOW); // Disabling standby
  digitalWrite(iRefR2, LOW);
  digitalWrite(iRefR3, LOW);

  
  digitalWrite(uartMode, LOW);
  SPI.begin();
  SPI.beginTransaction(SPISettings(500000, MSBFIRST, SPI_MODE3));
  
  delay(10);
  
  //set resistance to 10K
  digitalWrite(iRefR2, HIGH);
  digitalWrite(iRefR3, HIGH);

  
  initMotorOne(IC_ID);
  
  tmc5272_writeRegister(IC_ID, TMC5272_RAMPMODE, 0x0); //set position mode  
  tmc5272_writeRegister(IC_ID, TMC5272_VSTART(0), 0); //set maximum valocity
  tmc5272_writeRegister(IC_ID, TMC5272_VSTOP(0), 10); //set maximum valocity
  tmc5272_writeRegister(IC_ID, TMC5272_TVMAX(0), 0); //disable jerk reduction
  tmc5272_writeRegister(IC_ID, TMC5272_AMAX(0), 50000); //set maximum acceleration
  tmc5272_writeRegister(IC_ID, TMC5272_VMAX(0), 100000); //set maximum valocity
  tmc5272_writeRegister(IC_ID, TMC5272_DMAX(0), 1000); //set maximum deacceleration
  tmc5272_writeRegister(IC_ID, TMC5272_D2(0), 1); 
  tmc5272_writeRegister(IC_ID, TMC5272_XACTUAL(0), 0); //clear actual position
 
  previous_value = analogRead(A0);
}



void loop() {
  
  int sensor_value = analogRead(A0);
  int diff = abs(sensor_value - previous_value);
  if(diff>30)
    tmc5272_writeRegister(IC_ID, TMC5272_XTARGET(0), sensor_value*10000); //set a target position
  previous_value = sensor_value;
  Serial.println(sensor_value);
  delay(15);

}

Watch the demo video below:

community.element14.com/.../Stepper-with-Flex-Sensor.mp4

Implementing StallGuard using Arduino

taifur — Thu, 26 Dec 2024 17:29:54 GMT

StallGuard is a sensorless load measurement technology for stepper motors. Implementing StallGuard in a stepper motor driver eliminates the need for reference or limit switches and reduces the complexity and cost where precise referencing is required such as 3D printers and CNC machines. Trinamic Motion Controller like TMC5272 supports StallGuard and CoolStep technology and using those features together we can make a cost effective and power efficient solution. TMC IDE offers tuning and testing StallGuard and CoolStep very effectively and we can take advantage from it during custom firmware design for MCU for controlling TMC5272 like stepper controllers.

StallGuard allows us to stop the motor to a specific load and we can set the sensitivity for the TMC5272. We can also set the upper and lower velocity threshold for enabling the StallGuard. Several registers of TMC5272 are involved with StallGuard and CoolStep and we need to programmatically control those registers from MCU. With the help of TMC IDE and the TMC5272 datasheet I was able to successfully implement StallGuard and CoolStep from Arduino.

Images are captured from TMC5272 datasheet. The sg_stop bit of SW_MODE register is responsible for enabling or disabling of StallGuard2 or 4.

This is the sample test code I wrote for Arduino for controlling StallGuard2.

/*******************************************************************************
* Copyright © 2023 Analog Devices Inc. All Rights Reserved.
* This software is proprietary to Analog Devices, Inc. and its licensors.
*******************************************************************************/

#include <SPI.h>

extern "C" {
#include "TMC5272_register_map.h"
#include "tmc5272.h"

}

/* 
 * Arduino Pins   Eval Board Pins
 * 51 MOSI        32 SPI1_SDI
 * 50 MISO        33 SPI1_SDO
 * 52 SCK         31 SPI1_SCK
 * 53 SS          30 SPI1_CSN
 * GND            23 CLK16 -> use internal 
 * 23 DIO         19 nSleep 
 * GND            2 GND
 * +5V            5 +5V_USB
 * 27 iRefR2      35 IREF_R2
 * 29 iRefR3      36 IRREF_R3
 * 31 uartMode    20 USEL/ for uart mode it should be HIGH
 */

#define IC_ID 0

int nSleep = 23;
int iRefR2 = 27;
int iRefR3 = 29;
int uartMode = 31;

void tmc5272_readWriteSPI(uint16_t icID, uint8_t *data, size_t dataLength) {
  digitalWrite(PIN_SPI_SS, LOW);
  delayMicroseconds(10);

  for (uint32_t i = 0; i < dataLength; i++) {
    data[i] = SPI.transfer(data[i]);
    Serial.println(data[i]);
  }

  delayMicroseconds(10);
  digitalWrite(PIN_SPI_SS, HIGH);
}

void setup() {
  Serial.begin(115200);

  // put your setup code here, to run once:
  pinMode(PIN_SPI_SS, OUTPUT);
  pinMode(nSleep, OUTPUT);
  pinMode(iRefR2, OUTPUT);
  pinMode(iRefR3, OUTPUT);
  pinMode(uartMode, OUTPUT);

  digitalWrite(PIN_SPI_SS, HIGH);
  digitalWrite(nSleep, LOW); // Disabling standby
  digitalWrite(iRefR2, LOW);
  digitalWrite(iRefR3, LOW);

  
  digitalWrite(uartMode, LOW);
  SPI.begin();
  SPI.beginTransaction(SPISettings(500000, MSBFIRST, SPI_MODE3));
  
  delay(10);
  
  //set resistance to 10K
  digitalWrite(iRefR2, HIGH);
  digitalWrite(iRefR3, HIGH);

  initMotorOne(IC_ID);
  
  //tmc5272_rotateMotor(IC_ID, 0, 0x00005000);

  tmc5272_writeRegister(IC_ID, TMC5272_TPWMTHRS(0), 0x1500000); //this is the upper velocity for StealthChop2 voltage PWM mode, ST2 is enable if TSTEP>=TPWMTHRS
  tmc5272_writeRegister(IC_ID, TMC5272_TCOOLTHRS(0), 0x50000);//lower velocity threshold for switching CoolStep and StallGuard2/4 features, enable if TCOOLTHRS >= TSTEP
  tmc5272_writeRegister(IC_ID, TMC5272_THIGH(0), 0x0);//upper velocity threshold for switching CoolStep, disabled if TSTEP <= THIGH
  tmc5272_writeRegister(IC_ID, TMC5272_SG4_THRS(0), 30); //stall detection threshold 
  //tmc5272_writeRegister(IC_ID, TMC5272_SW_MODE(0), 0x0);
  field_write(IC_ID, TMC5272_SW_MODE_SG_STOP_FIELD(0), 1); //enable stop by StallGuard2/4
 
  tmc5272_writeRegister(IC_ID, TMC5272_RAMPMODE, 0x0); //set position mode  
  tmc5272_writeRegister(IC_ID, TMC5272_VSTART(0), 0); //set maximum valocity
  tmc5272_writeRegister(IC_ID, TMC5272_VSTOP(0), 10); //set maximum valocity
  tmc5272_writeRegister(IC_ID, TMC5272_TVMAX(0), 0); //disable jerk reduction
  tmc5272_writeRegister(IC_ID, TMC5272_AMAX(0), 50000); //set maximum acceleration
  tmc5272_writeRegister(IC_ID, TMC5272_VMAX(0), 100000); //set maximum valocity
  tmc5272_writeRegister(IC_ID, TMC5272_DMAX(0), 1000); //set maximum deacceleration
  tmc5272_writeRegister(IC_ID, TMC5272_D2(0), 1); 
  tmc5272_writeRegister(IC_ID, TMC5272_XACTUAL(0), 0); //clear actual position
  tmc5272_writeRegister(IC_ID, TMC5272_XTARGET(0), 500000); //set a target position
  delay(10000);
  field_write(IC_ID, TMC5272_RAMP_STAT_STATUS_SG_FIELD(0), 0); //disable stop by StallGuard2/4
  field_write(IC_ID, TMC5272_SW_MODE_SG_STOP_FIELD(0), 0); //disable stop by StallGuard2/4
  tmc5272_writeRegister(IC_ID, TMC5272_XTARGET(0), 0); //return to home position
}

void loop() {
  
  int32_t value1 = tmc5272_readRegister(IC_ID, TMC5272_RAMP_STAT(0));
  int32_t value2 = tmc5272_readRegister(IC_ID, TMC5272_SG4_THRS(0));

  Serial.print("Received Data: ");
  Serial.print(value1, HEX);
  Serial.print("  ");
  Serial.println(value1);
  
}

I added some helpful comments in the code which can help you to easily understand the code and operation. In the code the driver is configure to drive the stepper motor in position mode. A target position is set to XTRAGT register. Motor moves clockwise to achieve the position and the StallGuard is enable in this journey. After reaching the target a 10s pause is set. The motor returns to home position again and this time the StallGuard is disable.

Watch the demo video below for the above code:

community.element14.com/.../StallGuard-with-Arduino.mp4

First 3D printed parts

amgalbu — Thu, 26 Dec 2024 15:34:08 GMT

The software part of this project is already there, so it's time to think about the physical part.

As I said, the goal of this project is to build a mechanism that can show the object being 3D-printed from every sides.

I have a delta printer, which has three legs. So I am going to create three supports a wheel will lean on. Each support will feature a toy car's wheel to reduce the friction and make the movement as smooth as possible.

This is the support with the toy car's wheel

The part is stuck on the leg as shown in picture below

The wheel the camera will be mounted on is made of eight sections as shown in picture. The wheel has been split in eight split because of the limited size of my printer. Sections has then been joined by means of hot glue

The wheel will move on the toy car's wheel

Inside the wheel, is visible the conductive tape that will bring the power supply to the wireless camera

Configuring the wireless camera

amgalbu — Tue, 24 Dec 2024 15:49:56 GMT

For the project I have in mind, the camera must be able to rotate continuously. For this reason, a USB webcam is not suitable and I will make camera from a Raspberry Pi Zero W board and a Raspberry Pi camera module.

To integrate the camera in Octoprint, I am going to install mjpg-streamer package, which can stream JPEG frames from various sources to various possible outputs.

To install mjpg-streamer, I will start from the dietpi distro. Here is a brief tutorial of the setup process

Step 1: Prepare the Raspberry Pi Zero W

Download DietPi Image:
- Visit the DietPi website.
- Navigate to the "Download" section and select the appropriate image for Raspberry Pi.

Flash the DietPi Image to MicroSD Card:
- Download and install a tool like balenaEtcher or Raspberry Pi Imager.
- Insert the microSD card into your computer.
- Use the tool to flash the downloaded DietPi image onto the microSD card.

Configure Wi-Fi (Optional):
- After flashing, you can enable Wi-Fi by editing the dietpi-wifi.txt file located in the boot partition of the microSD card.
- Enter your Wi-Fi credentials in the format provided in the file:
  
  bash
  
  aWIFI_SSID[0]='Your_SSID'
  
  aWIFI_KEY[0]='Your_Password'
Insert and Boot:
- Insert the microSD card into your Raspberry Pi Zero W.
- Power on the Raspberry Pi.

Step 2: Enable the camera module

The official Raspberry Pi camera module, it can be enabled via dietpi-config > Display Options > RPi Camera to show [On].
Additionally, the behaviour of the cameras LED can be set in the same dialog via RPi Camera LED.

Remark: After changing the camera activation you need to reboot and/or sometimes power cycle the SBC incl. camera.

Step 3: Configure MJPEG-Streamer

You can now configure MJPEG-Streamer. Run the following command:

dietpi-software

This will open the DietPi software management tool.

Scroll through the available software or use the search function (press / and type mjpeg).
Locate MJPEG-Streamer and select it by pressing the space bar. A [X] will appear next to it.
After selecting MJPEG-Streamer, press Enter to proceed to the next step.
DietPi-Software will prompt you to confirm the installation. Confirm and begin the installation process. DietPi will automatically handle the download, compilation, and installation of MJPEG-Streamer.
After the build and installation process completes, edit the file /etc/systemd/system/mjpg-streamer.service and replace mjpeg_streamer's commandline parameter "'input_raspicam.so" with "input_uvc.so"
Restart the board to apply changes

Step 4: Configure Octoprint

The final step is to configure the URL in Octoprint. From the Octoprint-s web interface, navigate to "Options", then select "Webcam classic" and enter the following URLs

Streaming URL: http://<OctoPi_IP>/stream
Snapshot URL: http://<PiZeroW_IP>:8082/?action=snapshot
Path to FFMPEG: This is required for features like time-lapse rendering. The typical path is: /usr/bin/ffmpeg

Note that the Streaming URL points to the IP of the Raspberry Pi running the Octopi software, not to the Raspberry Pi Zero W with the MJPEG Streamer. This is because modern browsers tend to block mixed contents (served via HTTPS and HTTP).To make the stream work, I changed the configuration of the haproxy. HAProxy (High Availability Proxy) is an open-source software solution that provides load balancing, reverse proxying, and high availability for TCP and HTTP-based applications. I edited file /etc/haproxy/haproxy.cfg and added a new backend in the frontend public section

frontend public
        bind :::80 v4v6
        bind :::443 v4v6 ssl crt /etc/ssl/snakeoil.pem
        option forwardfor except 127.0.0.1
        use_backend webcam if { path_beg /webcam/ }
        use_backend webcam_hls if { path_beg /hls/ }
        use_backend webcam_hls if { path_beg /jpeg/ }
        ########### NEW LINE ADDED ###########
        use_backend webcam_stream if { path_beg /stream }
        ######################################
        default_backend octoprint

The new backend has been added at the end of the same file. I simply replaced the /stream URL with the URL requested by MJPEG streamer, and added the IP address of the Raspberry Pi Zero W that runs MJPEG streamer application (192.168.118.100)

backend webcam_stream
        http-request replace-path /stream /?action=stream
        server webcam_stream1 192.168.118.100:8082

Forum - Recent Threads

Winners Announcement – Start A Movement Design Challenge

The Wrap-Up – Start A Movement Design Challenge

Don't forget to get your final updates in before the deadline! (and Happy New Year!)

AVR Part 5 – Connecting Variac and Stepper

The Variac

Stepper Motor

Coupling

3D Printing and Fitting

Conclusion

RangeDetect Rover 5# Coding for the Rover

Table of Contents

1 Function Description

2 The Hardware Interfaces

3 Software

4 How to improve it

AVR Part 4 - TMCL-IDE Setup and First Movements

Installation and Setup

Movements

Does It Get Hot?

Integration

Conclusion

ASM - Working more with the Sensor

AVR Part 3 - Connections and Power

Connecting the Motor

Power Supply

Conclusion

RangeDetect Rover 4# Quick-built Rover Platform

Table of Contents

1 Select Material for Quick-Build

2 Wheels and shaft coupler

3 Chassis

4 Bodywork and Compartment

ASM - Adjusting Torque and Current Rating

Tuning Current for a Good amount of Torque

Making Connections Fixed

AVR Part 2 - Unboxing

Unboxing

Conclusion

P.S.

RangeDetect Rover 3# Using MKR wifi 1010 as TMC5272 Control board

Table of Contents

1 MKR WIFI 1010

2 Interface Connectors

3 Arduino Library

4 Coding

5 Summary

ASM - 3D Printing and Assembly

Smart Conveyor Belt for Sorting System - Blog Series and Project Write-Up

Project Title: Smart Conveyor Belt for Sorting System

Project Overview

Key Objectives

Features and Highlights

Project Timeline

Why This Project Matters

RangeDetect Rover 2# Range Detector Sensors

Table of Contents

1 Introduction

2 HC-SR04

3 60GHz mmWare radar sensor

4 Sensor fusion and range detection

Thread Tapping System (Start a Movement Design Challenge))

Intro

Video - Assembled Thread Tapping System With Motors Running

Discussion

Links

AVR Part 1 - The Concept

Why "Start a Movement"?

The Problem and Concept

Conclusion

P.S.

Wireless camera

RangeDetect Rover 1# Unboxing and Roadtest to TMC5272-EVAL-KIT and TRINAMIC stepper motor

Table of Contents

1 Introduction

2 TMC5272-EVAL-KIT and TRINAMIC stepper motor

3 TMCL-IDE

4 Drive the stepper motor and Next to do

DIY Pick N Place - Vision Recognition

Building a Robust PCB Component Detection System with Jetson AI