The development team around Duinocoin inventor Robert Piotrowski (revoxhere) has released version 3.0 of the cryptocurrency tailored for microcontrollers.
Version 3.0 of the Duinocoin software brings more speed to the Arduino Uno, the ESP8266/ESP32 boards and other microcontrollers and thus higher hash rates for mining. There is a fancy, web-based dashboard for the ESP8266/ESP32 and the PC miner manages up to ten times the hash rate thanks to "fasthash".
Number of DUCO miners rises to over 20,000
Currently (on 07 February 2022), there are about 8000 ESP8266, 7000 Arduino, 800 PCs, 700 Raspberry Pi, 200 ESP32 and 200 web miners, 100 smartphones and 100 other miners working in the Duinocoin network. The Duinocoin (DUCO) unofficially stands at a tender US$0.00118381.
Hash rate on PC increased tenfold!
The old Duinocoin software version 2.74/2.75 dates from 15 November 2021 and ran quite stable. Before the new major release 3.0, there was a release candidate "3.0rc", which was replaced by the final 3.0 release only three days later. The new Duinocoin software is available for download as usual on Github.
For PC and Raspberry Pi users, the new "fasthash" function of the PC Miner should be interesting, because it is supposed to deliver a hash rate that is up to ten times higher. Technically, this is certainly a clear step forward. However, in view of the Kolka system, which rewards weak systems fairly and thus more than fast systems, the additional performance will hardly pay off in DUCO.
ESP8266/ESP32 with Dashboard
New in version 3.0 is a dashboard for the ESP family. Miners with the ESP8266 and the ESP32 show a small overview of the hash rate and some other info via a mini web server under their IP address. For larger mining farms, it would be better to combine this information on a single web page.
10% faster: Compiler optimisation for Arduino and ESP8266/ESP32
Those looking for changes in the mining algorithm (DUCO-S1) will unfortunately be disappointed. The speed increase for the microcontrollers comes from the optimisation of the GNU C Compiler (GCC). Instead of using the default setting as before, the Duinocoin software is now specifically optimised for speed.
#pragma GCC optimize ("-Ofast").
In the default setting, the GCC and other compilers optimise the code for microcontrollers with regard to size - i.e. they try to create the smallest possible binaries (the programme that can be executed on the microcontroller). The reason: with a microcontroller - for example in a washing machine - it is not a matter of a few percent more speed when executing the software. It is much more important to be able to save a few cents on the microcontroller by using, for example, a version with a little less memory - alternatively, you can perhaps build a few additional functions into an already planned microcontroller.
The Duinocoin software in version 3.0.
Optimisation for speed sometimes makes sense in real-time applications, for example in the software of a drone, a camera or perhaps a 3D printer. With the Duinocoin, this optimisation is not really necessary, as the Kolka system automatically rewards weaker systems with lower hash performance better than fast systems anyway. Nevertheless: More speed when mining always looks good and does no harm... right?
Problems due to the optimisation?
Optimising for speed automatically means that the binary for the microcontroller gets bigger. This is completely irrelevant with the Arduino UNO and the ESP8266/ESP32, but can be problematic with an ATtiny microcontroller with only a few KBytes of memory. If the mining software does not fit into the memory of the controller, you can remove the above option.
TIP: If the memory is very cramped
If the Duinocoin software does not fit into the memory of a microcontroller even with the default setting (without the above #PRAGMA statement), you could use a
#pragma GCC optimize ("-Os")
might help. With "-Os" for "size", GCC switches on all optimisation options of "-O2" - except for six options that take up space. If it still doesn't fit, you can use "-Oz" to tell GCC to optimise aggressively for memory, even if it means a loss of speed. More about the optimisation options of GCC can be found in its official documentation in chapter 3.11 Options That Control Optimization.