Recently this was posted in a C for Embedded programming Linkedin group.

Attention C programmers!
Here’s a quick trick that can make your code more efficient and save you time. Did you know that you can use the ternary operator to simplify if-else statements?

For example, instead of writing:

if(x > 0){
y = 1;
}
else{
y = 0;
}

You can simplify it to:

y = (x > 0) ? 1 : 0;

This is particularly useful when you have multiple if-else statements within a loop. By using the ternary operator, you can make your code more readable and reduce the number of lines, leading to improved performance.

Give it a try and let me know what you think! 

Before you get all enthusiastic about this it is important to note that it is unlikely that the compiler will produce different or better machine executable code in the suggested case. It is really worth every software engineer spending time looking at the assembly code to see how little effect code shortcuts have. And this ternary construct is not allowed in some code standards. This paragraph was what I posted to the discussion.

The linkedin thread continued.

One person commented

“A neat trick, although I doubt that better performance would be a benefit. One should beware of premature optimization and overusing this technique. Code readability is king!”

Another added

“In my opinion, the use of ternary operator is often used and abused in places where it actually makes the code less readable. Some coding rules actually prohibit the use of the ternary operator altogether.”

One other person said politely

“sorry to give you this information, but even without any optimization the compiler will produce the same assembly, you can try by yourself using one of the different tools online such as https://godbolt.org/.”

It looks like godbolt.org might be a fun tool to allow software people to look at assembler for different compilers.

It is always good to look at the compiled output assembler code. It shows you what you have actually done.

I was traveling before Christmas to get to a couple of meetings. A software guy in one of the meetings had to step out because there was a pressing issue with a serial communications system. He was back in about 20 minutes because he had “fixed it”. Turns out an IDE/Compiler/ToolChain code library had been updated automatically and this had broken the serial comms.

So how are you controlling how you version the toolchain libraries? Do you version the toolchain?

Do you just roll the automatic updates in? Do you do anything? #software #communications #versioncontrol

How do you version control the code tools for high quality software?

One option to control the version of toolchain libraries is to freeze the version used in a project by specifying a specific version number in the project’s build system. This can prevent unexpected changes and breakage caused by automatic updates. Another option is to have a dedicated team responsible for testing and controlling updates to the toolchain libraries, and only roll out updates that have been thoroughly tested and deemed stable. Additionally, organizations could also consider setting up their own internal repository for the toolchain libraries, with version control and a process for testing and releasing updates.

Having clear control and visibility into the toolchain libraries used in a project can greatly increase the stability and reliability of the system. It can also minimize downtime and improve the efficiency of debugging and fixing issues. Overall, having a well-defined version control strategy for the toolchain libraries can lead to a better software development process and improved product quality.

More often than not the silicon vendor-provided code is not available in a repository but comes as some self-installing executable. that checks for updates and installs said updates them without telling you what they are, This is such a problematic low-quality approach. So it was so cool to see this SDK from NXP that is delivered in it’s GitHub repo. Such a good way to do it. Well done NXP.

The link to the SDK information is https://spsdk.readthedocs.io/en/latest/spsdk.html#delivery

The GitHub link is https://github.com/nxp-mcuxpresso/spsdk.

Truly well done to NXP and whoever was in charge of setting this up.

Hopefully the other vendors will take the same approach.

The thorn in the side of the supercapacitor is its limited lifetime.

Supercapacitors can do many things in the field of energy storage and have be touted as being the future batteries.

However any supercapacitor if not lifetime-engineered properly can fail prematurely.  This leaves your company with potentially large warranty costs.

What is lifetime?

Supercapacitor lifetime stems from chemical reactions in the capacitor causing the capacitance to decrease.  These reactions happen more often when it is hotter and thus lifetime can vary significantally with temperature.  These reactions are governed by the Arhennius equation and appear on the datasheet as a lifetime.  A typical lifetime for a supercapacitor is 1000 hours at 70C.  This means that if your supercapacitor is at 70C it burns through a lifetime in 42 days!  At only 83C some electrolytes can even boil causing your supercapacitor to rupture!  However, if the temperature is decreased a supercapacitor’s lifetime can be increased greatly.  It is all governed by this equation:

where t is lifetime, T_n is the nominal temperature, t_n is the lifetime at the nominal temperature, E_a is the activation energy, T is temperature and k_B is Boltzmann’s constant.  In most cases this can be approximated by “halving the temperature doubles the lifetime”. If you are not using this equation in designing your supercapacitor systems then you better start using it fast!  Note that this equation is for any electrolytic capacitor not just supercapacitors.

Lowering voltage

From the prior equation it can be seen that managing the temperature of supercapacitors can do wonders in increasing their lifetime.  It is a lesser known fact that running them at voltages below the rated voltage also increases their lifetime.

Verify!

Once you have your product in the field, re-engineering can become costly, so verification of your design and predicting failure rates becomes very important.  This is done by measurement of the capacitors and then statistically analysing the results.

Measurement is important

Measurement of supercapacitors relies on the use of a simple capacitor model with just capacitance and ESR.  This allows measurement by using the fact that the voltage response to a constant current source is a straight line.  From this straight line you can thus measure the capacitance.  When a constant current is applied there is also a small offset due to the ESR, which can be used to measure the ESR.

After measurement

Once you made the measurements of a random group of supercapacitors you can begin to analyse the results.  First of all you calculate the lifetimes that the supercapacitors have experienced up to the measurements based on their capacitance.  Then these lifetime results typically fit a Weibull distribution. Using this fact, you can curve-fit your sampled data to a distribution with certain parameters and calculate the confidence of your fit.  You now have a range of distributions that fit your data.  From this range you simply find the worst case and use it to predict worst-case future failure rates.  This information can be passed on to the accountant in the form of warranty liability.

How can we help?

ELMG Ltd have designed a system which can use this measurement technique to measure supercapacitor’s capacitance during both charging and discharging.  This is done using a controlled constant current source.  This system is highly scalable meaning that it can be used on capacitors ranging from a few farads to hundreds of farads.  Once the measurements are made ELMG can then perform the statistical analysis and come up the results to tell your finance people what you warranty liability is.

ELMG Digital Power is an AMD-Xilinx Partner. As part of this we keep up to date with Xilinx parts, tools and technology with training. Consequently ELMG can provide the best digital control solutions for digital power electronics.

We started digital control of power electronics with Xilinx in 1997 so as a result ELMG Digital Power’s long history with Xilinx means that we have exceptional experience and expertise.

ELMG Digital Power for Digital Power Electronics Control expertise.

Softcore processing in FPGA is a great option to get sequential processing in a RTL design.

Adam Taylor ran a workshop on how to use Xilinx MicroBlaze in FPGAs.

If you are interested in FPGA control for Power Electronics then a soft core is really useful.

Adam is great at Xilinx FPGA and we’d recommend his training to anyone wanting to learn about MicroBlaze on FPGA.

Click the link to view the recording.

Mastering MicroBlaze with Adam Taylor

Enjoy the training.