Raspberry Pi Compute Module 5, nVME Baseboards, WebScreen Clip-On Display, and more!

0:00:00 / -

Watch now on YouTube Watch now

Crypto Mining Using Nodemcu

Made by tarantula3 / Communication / Home Automation / Productivity / Sensors / IoT

About the project

Crypto Mining using microcontrollers, wait what!!! Are you serious? How? Believe it or not, that is possible...

Project info

Difficulty: Easy

Platforms: Arduino, NodeMCU, PCBWay

Estimated time: 1 hour

License: GNU General Public License, version 3 or later (GPL3+)

Items used in this project

Hardware components

	NodeMCU v2-Lua based ESP8266 development kit	x 5
	LED - Basic Red 3mm	x 1

Story

Crypto Mining using microcontrollers, wait what!!! Are you serious? How?Believe it or not, the rig you see onscreen actually mines a crypto currency called DUINO-Coin (á•²) or DUCO. The total cost of this rig is only $35.Now, if you believe me! then, grab yourself a cup of coffee, sit back and watch this video and start your journey into cryptocurrency with DUINO-Coin!

What is DUINO-Coin?

DUINO-Coin (á•²) was founded in 2019 and is a for-fun project. This project was developed by a team of young developers that focuses on energy efficient mining. It's mostly, but not only, dedicated to people who are just starting out in the crypto world and it doesn't require any expensive hardware.DUCO is a transparent, open-source, centralized, eco-friendly coin that focuses on mining with low-powered devices like Arduino. DUCO tries to achieve a reward system using "Kolka" a name derived from Coca Cola making the low-powered devices like Arduino earn almost the same or even "more" than a powerful device like CPUs or GPUs. It also prevents people from building huge mining farms. It causes each additional miner to earn a bit less from the previous one.DUCO is "centralized" and has an "infinite supply" and hence you can mine this coin forever.
You can Mine DUCO using: Android smartphone Computer's CPU Arduino (or compatible AVR) Raspberry Pi, Orange Pi or Banana Pi ESP8266/ESP32 (or compatible boards) Internet browser on PC or smart-TVs Arduinos using ESP8266 as a host Arduinos using Raspberry Pi as a host
Centralization: Making Arduino and other low powered devices not only profitable, but just possible would be impossible to maintain if the coin was decentralized. Hence, DuCo is a centralized coin with it's own chain. It is however possible to wrap (convert) DUCOs to wDUCO, bscDUCO, celoDUCO or maticDUCO to store them in decentralized form on another coin's chain.
To start your journey, have a look at the getting started with Duino-Coin webpage. Then, create a wallet to store your coins. Next, download the miner binaries for the device you are going to mine the coin.If you are super tech savvy, then have a look at the coins whitepapers. The link is in the description below.
In my setup, I am mining DUCO using NodeMCU.

Schema

The setup is very simple. In my setup I have added an extra LED to give my board a bit of Si-Fi look.Mining with ESP boards allows you to mine headlessly - you don't need to have them connected to a computer as they have their own Wi-Fi capabilities to connect to the server.

The Board

Now, lets have a look at my board. You can hookup, 5 x NodeMCUs to this board. Each NodeMCU has its own flashing LED. The board can be powered using just 5v using a USB cable.So, this is how the NodeMCU DUCO Miner blade looks like in 3D.

Soldering

Lets start by soldering all the small components to the board. I first soldered all the LEDs and the resistances to the board.Since I care a lot about my Sensors and Microcontrollers, I am not going to solder them directly to the board. Instead I am soldering 'female pin headers' to the board which will house the NodeMCUs in them.
Finally, I soldered a USB cable to power the blade. I extracted this cable from a broken iPhone's charger.

Code

I downloaded the code from the DUINO-coins website. The current version is 3.0. I downloaded the windows version and then added my code block to make the blue LED flash on my blade. In the code, you just need to edit few line in the top section to add your Wi-Fi details and the name of the NodeMCU.
If you're using an ESP8266 board, you can set the clock speed (Tools > CPU frequency) to 160 MHz to achieve better hash-rates.

Then, just go ahead and upload the code one by one to all your NodeMCU's. Before adding the NodeMCU to your rig, it is a good idea to check it using the Arduino Serial Monitor (Tools > Serial Monitor), set the baud rate to 500000 baud and see how's the ESP is doing. If everything is correct, you should see messages saying that a share was accepted.If it all works fine, your ESP will mine as long as it has power and internet connection.

Demo

So, this is how my final setup looks like.To be very frank, the setup actually looks like having a small Christmas tree on your table, ha ha.

Hash-Rate

Mining DUCO at this stage is not very profitable. However, I just wanted to share the hash-rate table with you guys.Remember, Kolka will play an essential role, as you keep on adding devices to your rig. So, the hash-rate you will get may not be same as what you see on-screen.

Claiming Via Faucets

You can also claim DUCO via web-faucets.I have scene many faucets coming in and completely disappearing, so the links provided in the video may not be valid when you try to access them.The first one in list is the "faucet.duinocoin.com". You can claim 1 DUCO from this website by solving a captcha to start your journey. Remember you can only claim once from this website.The next one is the "furim.xyz". Again, you just need to solve a captcha to earn some DUCO.The 3rd one in list is "duco-faucet.pcgeek.pl" same as the other two, you can claim some DUCO every 15 minutes by solving a captcha on this website.

Exchanging DUCO

After mining some DUINO-Coins, you may want to exchange them to some other currency. To exchange your coins, simply visit the website and select the currency you want to exchange. At the moment of writing this tutorial, DUCO Exchange supports XMG, BCH, TRX, BYND and LKE coins.After deciding which coin you want exchanged, simply fill in the exchange form and wait for the exchange to happen (it may take up to 72 hours). You'll shortly receive an e-mail confirming the process and describing any further steps if needed.
Other exchanges:Other exchanges supporting DUINO-Coin are Node-S, PancakeSwap, SunSwap, and SushiSwap.

Thanks

Thanks again for checking my post. I hope it helps you.If you want to support me subscribe to my YouTube Channel: https://www.youtube.com/user/tarantula3

Blog Posts: Visit Website

Video references: Visit Website

Code

Release 3.0 Original: Download

Release 3.0 Modified: Download

Resource Pages

Getting started: Visit Website

Create Wallet: Visit Website

App list: Visit Website

Exchange: Visit Website

White Paper: Visit Website

Dashboards

Dashboard-1: Visit Website

Dashboard-2: Visit Website

Dashboard-3: Visit Website

Facets List

Faucet-1: Visit Website

Faucet-2: Visit Website

Faucet-3: Visit Website

Discussion

Discord: Visit Website

Reddit : Visit Website

Support My Work:

BTC: 1M1PdxVxSTPLoMK91XnvEPksVuAa4J4dDp

LTC: MQFkVkWimYngMwp5SMuSbMP4ADStjysstm

DOGE: DDe7Fws24zf7acZevoT8uERnmisiHwR5st

ETH: 0x939aa4e13ecb4b46663c8017986abc0d204cde60

BAT: 0x939aa4e13ecb4b46663c8017986abc0d204cde60

LBC: bZ8ANEJFsd2MNFfpoxBhtFNPboh7PmD7M2
Thanks, ca again in my next tutorial.

Schematics, diagrams and documents

Code

/*
   ____  __  __  ____  _  _  _____       ___  _____  ____  _  _ 
  (  _ \(  )(  )(_  _)( \( )(  _  )___  / __)(  _  )(_  _)( \( )
   )(_) ))(__)(  _)(_  )  (  )(_)((___)( (__  )(_)(  _)(_  )  ( 
  (____/(______)(____)(_)\_)(_____)     \___)(_____)(____)(_)\_)
																		 
  Official code for ESP8266 boards                   version 3.0

  Duino-Coin Team & Community 2019-2022 © MIT Licensed
  https://duinocoin.com
  https://github.com/revoxhere/duino-coin

  If you don't know where to start, visit official website and navigate to
  the Getting Started page. Have fun mining!
*/

/* If optimizations cause problems, change them to -O0 (the default)
NOTE: For even better optimizations also edit your Crypto.h file.
On linux that file can be found in the following location:
~/.arduino15//packages/esp8266/hardware/esp8266/3.0.2/cores/esp8266/ */
#pragma GCC optimize ("-Ofast")

/* If during compilation the line below causes a
  "fatal error: arduinoJson.h: No such file or directory"
  message to occur; it means that you do NOT have the
  ArduinoJSON library installed. To install it, 
  go to the below link and follow the instructions: 
  https://github.com/revoxhere/duino-coin/issues/832 */
#include <ArduinoJson.h>

/* If during compilation the line below causes a
  "fatal error: Crypto.h: No such file or directory"
  message to occur; it means that you do NOT have the
  latest version of the ESP8266/Arduino Core library.
  To install/upgrade it, go to the below link and
  follow the instructions of the readme file:
  https://github.com/esp8266/Arduino */
#include <bearssl/bearssl.h>
#include <TypeConversion.h>

#include <ESP8266WiFi.h>
#include <ESP8266mDNS.h>
#include <WiFiUdp.h>
#include <ArduinoOTA.h>
#include <ESP8266HTTPClient.h>
#include <WiFiClient.h>
#include <Ticker.h>
#include <ESP8266WebServer.h>

namespace {
const char* SSID = "XXXXXX";                // Change this to your WiFi name
const char* PASSWORD = "XXXXXXXX";          // Change this to your WiFi password
const char* USERNAME = "XXXXXXXX";          // Change this to your Duino-Coin username
const char* RIG_IDENTIFIER = "ITS-ESP-XXX"; // Change this if you want a custom miner name (or use Auto to autogenerate)
const bool USE_HIGHER_DIFF = true;          // Change false to true if using 160 MHz clock mode to not get the first share rejected
const bool WEB_HASH_UPDATER = false;        // Change false to true if you want to update hashrate in browser without reloading page
const bool LED_BLINKING = true; // Change true to false if you want to disable led blinking (But the LED will work in the beginning until esp connects to the pool)


/* Do not change the lines below. These lines are static and dynamic variables
   that will be used by the program for counters and measurements. */
const char * DEVICE = "ESP8266";
const char * POOLPICKER_URL[] = {"https://server.duinocoin.com/getPool"};
const char * MINER_BANNER = "Official ESP8266 Miner";
const char * MINER_VER = "3.0";
unsigned int share_count = 0;
unsigned int port = 0;
unsigned int difficulty = 0;
float hashrate = 0;
String AutoRigName = "";
String host = "";
String node_id = "";

const char WEBSITE[] PROGMEM = R"=====(
<!DOCTYPE html>
<html>
<!--
    Duino-Coin self-hosted dashboard
    MIT licensed
    Duino-Coin official 2019-2021
    https://github.com/revoxhere/duino-coin
    https://duinocoin.com
-->

<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Duino-Coin @@DEVICE@@ dashboard</title>
    <link rel="stylesheet" href="https://server.duinocoin.com/assets/css/mystyles.css">
    <link rel="shortcut icon" href="https://github.com/revoxhere/duino-coin/blob/master/Resources/duco.png?raw=true">
    <link rel="icon" type="image/png" href="https://github.com/revoxhere/duino-coin/blob/master/Resources/duco.png?raw=true">
</head>

<body>
    <section class="section">
        <div class="container">
            <h1 class="title">
                <img class="icon" src="https://github.com/revoxhere/duino-coin/blob/master/Resources/duco.png?raw=true">
                @@DEVICE@@ <small>(@@ID@@)</small>
            </h1>
            <p class="subtitle">
                Self-hosted, lightweight, official dashboard for your <strong>Duino-Coin</strong> miner
            </p>
        </div>
        <br>
        <div class="container">
            <div class="columns">
                <div class="column">
                    <div class="box">
                        <p class="subtitle">
                            Mining statistics
                        </p>
                        <div class="columns is-multiline">
                            <div class="column" style="min-width:15em">
                                <div class="title is-size-5 mb-0">
                                    <span id="hashratex">@@HASHRATE@@</span>kH/s
                                </div>
                                <div class="heading is-size-5">
                                    Hashrate
                                </div>
                            </div>
                            <div class="column" style="min-width:15em">
                                <div class="title is-size-5 mb-0">
                                    @@DIFF@@
                                </div>
                                <div class="heading is-size-5">
                                    Difficulty
                                </div>
                            </div>
                            <div class="column" style="min-width:15em">
                                <div class="title is-size-5 mb-0">
                                    @@SHARES@@
                                </div>
                                <div class="heading is-size-5">
                                    Shares
                                </div>
                            </div>
                            <div class="column" style="min-width:15em">
                                <div class="title is-size-5 mb-0">
                                    @@NODE@@
                                </div>
                                <div class="heading is-size-5">
                                    Node
                                </div>
                            </div>
                        </div>
                    </div>
                </div>
                <div class="column">
                    <div class="box">
                        <p class="subtitle">
                            Device information
                        </p>
                        <div class="columns is-multiline">
                            <div class="column" style="min-width:15em">
                                <div class="title is-size-5 mb-0">
                                    @@DEVICE@@
                                </div>
                                <div class="heading is-size-5">
                                    Device type
                                </div>
                            </div>
                            <div class="column" style="min-width:15em">
                                <div class="title is-size-5 mb-0">
                                    @@ID@@
                                </div>
                                <div class="heading is-size-5">
                                    Device ID
                                </div>
                            </div>
                            <div class="column" style="min-width:15em">
                                <div class="title is-size-5 mb-0">
                                    @@MEMORY@@
                                </div>
                                <div class="heading is-size-5">
                                    Free memory
                                </div>
                            </div>
                            <div class="column" style="min-width:15em">
                                <div class="title is-size-5 mb-0">
                                    @@VERSION@@
                                </div>
                                <div class="heading is-size-5">
                                    Miner version
                                </div>
                            </div>
                        </div>
                    </div>
                </div>
            </div>
            <br>
            <div class="has-text-centered">
                <div class="title is-size-6 mb-0">
                    Hosted on
                    <a href="http://@@IP_ADDR@@">
                        http://<b>@@IP_ADDR@@</b>
                    </a>
                    •
                    <a href="https://duinocoin.com">
                        duinocoin.com
                    </a>
                    •
                    <a href="https://github.com/revoxhere/duino-coin">
                        github.com/revoxhere/duino-coin
                    </a>
                </div>
            </div>
        </div>
        <script>
            setInterval(function(){
                getData();
            }, 3000);
            
            function getData() {
                var xhttp = new XMLHttpRequest();
                xhttp.onreadystatechange = function() {
                    if (this.readyState == 4 && this.status == 200) {
                        document.getElementById("hashratex").innerHTML = this.responseText;
                    }
                };
                xhttp.open("GET", "hashrateread", true);
                xhttp.send();
            }
        </script>
    </section>
</body>

</html>
)=====";

ESP8266WebServer server(80);

void hashupdater(){ //update hashrate every 3 sec in browser without reloading page
  server.send(200, "text/plane", String(hashrate / 1000));
  Serial.println("Update hashrate on page");
};

void UpdateHostPort(String input) {
  // Thanks @ricaun for the code
  DynamicJsonDocument doc(256);
  deserializeJson(doc, input);

  const char* name = doc["name"];
  
  host = String((const char*)doc["ip"]);
  port = int(doc["port"]);
  node_id = String(name);

  Serial.println("Poolpicker selected the best mining node: " + node_id);
}

String httpGetString(String URL) {
  String payload = "";
  WiFiClientSecure client;
  client.setInsecure();
  HTTPClient http;
  
  if (http.begin(client, URL)) {
   
    int httpCode = http.GET();    
    if (httpCode == HTTP_CODE_OK) payload = http.getString();
    else Serial.printf("Error fetching node from poolpicker: %s\n", http.errorToString(httpCode).c_str());

    http.end();
  }
  return payload;
}

void UpdatePool() {
  String input = "";
  int waitTime = 1;
  int poolIndex = 0;
  int poolSize = sizeof(POOLPICKER_URL) / sizeof(char*);

  while (input == "") {
    Serial.println("Fetching mining node from the poolpicker in " + String(waitTime) + "s");
    input = httpGetString(POOLPICKER_URL[poolIndex]);
    poolIndex += 1;

    // Check if pool index needs to roll over
    if( poolIndex >= poolSize ){
																		 
      poolIndex %= poolSize;
      delay(waitTime * 1000);

      // Increase wait time till a maximum of 32 seconds (addresses: Limit connection requests on failure in ESP boards #1041)
      waitTime *= 2;
      if( waitTime > 32 )
        waitTime = 32;
    }
  }

  // Setup pool with new input
  UpdateHostPort(input);
}

WiFiClient client;
String client_buffer = "";
String chipID = "";
String START_DIFF = "";

// Loop WDT... please don't feed me...
// See lwdtcb() and lwdtFeed() below
Ticker lwdTimer;
#define LWD_TIMEOUT   60000

unsigned long lwdCurrentMillis = 0;
unsigned long lwdTimeOutMillis = LWD_TIMEOUT;

#define END_TOKEN  '\n'
#define SEP_TOKEN  ','

#define LED_BUILTIN 2
#define LED1 D1

#define BLINK_SHARE_FOUND    1
#define BLINK_SETUP_COMPLETE 2
#define BLINK_CLIENT_CONNECT 3
#define BLINK_RESET_DEVICE   5

void SetupWifi() {
  Serial.println("Connecting to: " + String(SSID));
  WiFi.mode(WIFI_STA); // Setup ESP in client mode
  WiFi.setSleepMode(WIFI_NONE_SLEEP);
  WiFi.begin(SSID, PASSWORD);

  int wait_passes = 0;
  while (WiFi.waitForConnectResult() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
    if (++wait_passes >= 10) {
      WiFi.begin(SSID, PASSWORD);
      wait_passes = 0;
    }
  }

  Serial.println("\n\nnSuccessfully connected to WiFi");
  Serial.println("Local IP address: " + WiFi.localIP().toString());
  Serial.println("Rig name: " + String(RIG_IDENTIFIER));
  Serial.println();

  UpdatePool();
}

void SetupOTA() {
  // Prepare OTA handler
  ArduinoOTA.onStart([]() {
    Serial.println("Start");
  });
  ArduinoOTA.onEnd([]() {
    Serial.println("\nEnd");
  });
  ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
    Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
  });
  ArduinoOTA.onError([](ota_error_t error) {
    Serial.printf("Error[%u]: ", error);
    if (error == OTA_AUTH_ERROR) Serial.println("Auth Failed");
    else if (error == OTA_BEGIN_ERROR) Serial.println("Begin Failed");
    else if (error == OTA_CONNECT_ERROR) Serial.println("Connect Failed");
    else if (error == OTA_RECEIVE_ERROR) Serial.println("Receive Failed");
    else if (error == OTA_END_ERROR) Serial.println("End Failed");
  });

  ArduinoOTA.setHostname(RIG_IDENTIFIER); // Give port a name not just address
  ArduinoOTA.begin();
}

void blink(uint8_t count, uint8_t pin = LED_BUILTIN) {
  if (LED_BLINKING){
    uint8_t state = HIGH;

    for (int x = 0; x < (count << 1); ++x) {
      digitalWrite(pin, state ^= HIGH);
      digitalWrite(LED1, HIGH);					// Blinking the Secondary LED
      delay(50);
      digitalWrite(LED1, LOW);
    }
  }
}

void RestartESP(String msg) {
  Serial.println(msg);
  Serial.println("Restarting ESP...");
  blink(BLINK_RESET_DEVICE);
  ESP.reset();
}

// Our new WDT to help prevent freezes
// code concept taken from https://sigmdel.ca/michel/program/esp8266/arduino/watchdogs2_en.html
void ICACHE_RAM_ATTR lwdtcb(void) {
 
  if ((millis() - lwdCurrentMillis > LWD_TIMEOUT) || (lwdTimeOutMillis - lwdCurrentMillis != LWD_TIMEOUT))
    RestartESP("Loop WDT Failed!");
}

void lwdtFeed(void) {
  lwdCurrentMillis = millis();
  lwdTimeOutMillis = lwdCurrentMillis + LWD_TIMEOUT;
}

void VerifyWifi() {
  while (WiFi.status() != WL_CONNECTED || WiFi.localIP() == IPAddress(0, 0, 0, 0))
    WiFi.reconnect();
}

void handleSystemEvents(void) {
  VerifyWifi();
  ArduinoOTA.handle();
  yield();
}

// https://stackoverflow.com/questions/9072320/split-string-into-string-array
String getValue(String data, char separator, int index)
{
  int found = 0;
  int strIndex[] = {0, -1};
  int max_index = data.length() - 1;

  for (int i = 0; i <= max_index && found <= index; i++) {
    if (data.charAt(i) == separator || i == max_index) {
      found++;
      strIndex[0] = strIndex[1] + 1;
      strIndex[1] = (i == max_index) ? i + 1 : i;
    }
  }
  return found > index ? data.substring(strIndex[0], strIndex[1]) : "";
}

void waitForClientData(void) {
  client_buffer = "";

  while (client.connected()) {
    if (client.available()) {
      client_buffer = client.readStringUntil(END_TOKEN);
      if (client_buffer.length() == 1 && client_buffer[0] == END_TOKEN)
        client_buffer = "???\n"; // NOTE: Should never happen

      break;
    }
    handleSystemEvents();
  }
}

void ConnectToServer() {
  if (client.connected())
    return;

  Serial.println("\n\nConnecting to the Duino-Coin server...");
  while (!client.connect(host, port));

  waitForClientData();
  Serial.println("Connected to the server. Server version: " + client_buffer );
  blink(BLINK_CLIENT_CONNECT); // Sucessfull connection with the server
}

bool max_micros_elapsed(unsigned long current, unsigned long max_elapsed) {
  static unsigned long _start = 0;

  if ((current - _start) > max_elapsed) {
    _start = current;
    return true;
  }
  return false;
}

void dashboard() {
  Serial.println("Handling HTTP client");

  String s = WEBSITE;
  s.replace("@@IP_ADDR@@", WiFi.localIP().toString());
  
  s.replace("@@HASHRATE@@", String(hashrate / 1000));
  s.replace("@@DIFF@@", String(difficulty / 100));
  s.replace("@@SHARES@@", String(share_count));
  s.replace("@@NODE@@", String(node_id));

  s.replace("@@DEVICE@@", String(DEVICE));
  s.replace("@@ID@@", String(RIG_IDENTIFIER));
  s.replace("@@MEMORY@@", String(ESP.getFreeHeap()));
  s.replace("@@VERSION@@", String(MINER_VER));

  server.send(200, "text/html", s);
}

} // namespace

void setup() {
  Serial.begin(500000);
  Serial.println("\nDuino-Coin " + String(MINER_VER));
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(LED1, OUTPUT);

  // Autogenerate ID if required
  chipID = String(ESP.getChipId(), HEX);
  if( strcmp(RIG_IDENTIFIER, "Auto") == 0 ){
    AutoRigName = "ESP8266-" + chipID;
    AutoRigName.toUpperCase();
    RIG_IDENTIFIER = AutoRigName.c_str();
  }

  SetupWifi();
  SetupOTA();

  lwdtFeed();
  lwdTimer.attach_ms(LWD_TIMEOUT, lwdtcb);
  if (USE_HIGHER_DIFF) START_DIFF = "ESP8266H";
  else START_DIFF = "ESP8266";

  if (!MDNS.begin(RIG_IDENTIFIER)) {
    Serial.println("mDNS unavailable");
  }
  MDNS.addService("http", "tcp", 80);
  Serial.print("Configured mDNS for dashboard on http://" 
                + String(RIG_IDENTIFIER)
                + ".local (or http://"
                + WiFi.localIP().toString()
                + ")");
  server.on("/", dashboard);
  if (WEB_HASH_UPDATER) server.on("/hashrateread", hashupdater);
  server.begin();

  blink(BLINK_SETUP_COMPLETE);
}

void loop() {
  br_sha1_context sha1_ctx, sha1_ctx_base;
  uint8_t hashArray[20];
  String duco_numeric_result_str;
  
  // 1 minute watchdog
  lwdtFeed();

  // OTA handlers
  VerifyWifi();
  ArduinoOTA.handle();
  server.handleClient();

  ConnectToServer();
  Serial.println("Asking for a new job for user: " + String(USERNAME));
  client.print("JOB," + String(USERNAME) + "," + String(START_DIFF));

  waitForClientData();
  String last_block_hash = getValue(client_buffer, SEP_TOKEN, 0);
  String expected_hash = getValue(client_buffer, SEP_TOKEN, 1);
  difficulty = getValue(client_buffer, SEP_TOKEN, 2).toInt() * 100 + 1;

  int job_len = last_block_hash.length() + expected_hash.length() + String(difficulty).length();
  Serial.println("Received a correct job with size of " + String(job_len) + " bytes");
					  
									   
  expected_hash.toUpperCase();
  br_sha1_init(&sha1_ctx_base);
  br_sha1_update(&sha1_ctx_base, last_block_hash.c_str(), last_block_hash.length());

  float start_time = micros();
  max_micros_elapsed(start_time, 0);

  String result = "";
  digitalWrite(LED_BUILTIN, HIGH);
  for (unsigned int duco_numeric_result = 0; duco_numeric_result < difficulty; duco_numeric_result++) {
    // Difficulty loop
    sha1_ctx = sha1_ctx_base;
    duco_numeric_result_str = String(duco_numeric_result);
    br_sha1_update(&sha1_ctx, duco_numeric_result_str.c_str(), duco_numeric_result_str.length());
    br_sha1_out(&sha1_ctx, hashArray);
    result = experimental::TypeConversion::uint8ArrayToHexString(hashArray, 20);
    if (result == expected_hash) {
      // If result is found
      unsigned long elapsed_time = micros() - start_time;
      float elapsed_time_s = elapsed_time * .000001f;
      hashrate = duco_numeric_result / elapsed_time_s;
      share_count++;
      blink(BLINK_SHARE_FOUND);

      client.print(String(duco_numeric_result)
                   + ","
                   + String(hashrate)
                   + ","
                   + String(MINER_BANNER)
                   + " "
                   + String(MINER_VER)
                   + ","
                   + String(RIG_IDENTIFIER)
                   + ",DUCOID"
                   + String(chipID));

      waitForClientData();
      Serial.println(client_buffer
                     + " share #"
                     + String(share_count)
                     + " (" + String(duco_numeric_result) + ")"
                     + " hashrate: "
                     + String(hashrate / 1000, 2)
                     + " kH/s ("
                     + String(elapsed_time_s)
                     + "s)");

							   
      break;
    }
    if (max_micros_elapsed(micros(), 500000))
    {
      handleSystemEvents();
    }
    else
    {
      delay(0);
    }
  }
}

Credits

tarantula3

There were 1000+ sperms but I was the fastest one..

Shop

Project Hub

Video

Blog

Shop home

3D printing

Single Board Computers

Development kits

Sensors

Internet of things

Robotics

Accessories

Product of the Week

Electromaker Educator

The Electromaker Show

The Electromaker Podcast

Crypto Mining Using Nodemcu

About the project

Project info