WantClue/NerdNos-Firmware
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert "Merge branch 'master' of https://github.com/alcar21/NerdMiner_v2 into feature/add_platformio_support_and_improvements"

Browse Source 
This reverts commit 8884bb58d7.
This commit is contained in:
Alfonso C. Alvarez 2023-05-03 21:11:59 +02:00
parent 8884bb58d7
commit 0aabedcbd1
5 changed files with 116 additions and 167 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -1,4 +1,3 @@
.pio .pio
.vscode .vscode
NerdMinerLog.txt NerdMinerLog.txt
platformio-device-monitor*.log

8
platformio.ini
View File

@ -18,20 +18,22 @@ framework = arduino
monitor_filters = monitor_filters =
esp32_exception_decoder esp32_exception_decoder
time time
log2file
board_build.arduino.memory_type = qio_opi board_build.arduino.memory_type = qio_opi
monitor_speed = 115200 monitor_speed = 115200
upload_speed = 115200 upload_speed = 115200
# 2 x 4.5MB app, 6.875MB SPIFFS
;board_build.partitions = large_spiffs_16MB.csv
;board_build.partitions = default_8MB.csv
board_build.partitions = huge_app.csv board_build.partitions = huge_app.csv
;board_build.partitions = default.csv
build_flags = build_flags =
-D LV_LVGL_H_INCLUDE_SIMPLE -D LV_LVGL_H_INCLUDE_SIMPLE
-D BOARD_HAS_PSRAM -D BOARD_HAS_PSRAM
-D ARDUINO_USB_MODE=1 -D ARDUINO_USB_MODE=1
-D ARDUINO_USB_CDC_ON_BOOT=1 -D ARDUINO_USB_CDC_ON_BOOT=1
-D DEBUG_MINING=1 ;-D DEBUG_MINING=1
;-D DEBUG_MINING_SHARE
lib_deps = lib_deps =
https://github.com/takkaO/OpenFontRender https://github.com/takkaO/OpenFontRender
bblanchon/ArduinoJson@^6.21.2 bblanchon/ArduinoJson@^6.21.2

6
src/NerdMinerV2.ino.cpp
View File

@ -79,6 +79,7 @@ void setup()
// Higher prio monitor task // Higher prio monitor task
Serial.println(""); Serial.println("");
Serial.println("Initiating tasks..."); Serial.println("Initiating tasks...");
xTaskCreate(runMonitor, "Monitor", 5000, NULL, 4, NULL);
/******** CREATE MINER TASKS *****/ /******** CREATE MINER TASKS *****/
for (size_t i = 0; i < THREADS; i++) { for (size_t i = 0; i < THREADS; i++) {
@ -87,10 +88,8 @@ void setup()
// Start mining tasks // Start mining tasks
BaseType_t res = xTaskCreate(runWorker, name, 30000, (void*)name, 1, NULL); BaseType_t res = xTaskCreate(runWorker, name, 30000, (void*)name, 1, NULL);
Serial.printf("Starting miner %s %s!\n", name, res == pdPASS? "successful":"failed"); Serial.printf("Starting %s %s!\n", name, res == pdPASS? "successful":"failed");
} }
Serial.println("NerdMiner v2 started......");
} }
void app_error_fault_handler(void *arg) { void app_error_fault_handler(void *arg) {
@ -124,5 +123,4 @@ void loop() {
//Run miner on main core when there is time --Currently on test //Run miner on main core when there is time --Currently on test
runMiner(); runMiner();
runMonitor();
} }

253
src/mining.cpp
View File

@ -3,7 +3,6 @@
#include <WiFi.h> #include <WiFi.h>
#include <algorithm> #include <algorithm>
#include <TFT_eSPI.h> // Graphics and font library for ILI9341 driver chip #include <TFT_eSPI.h> // Graphics and font library for ILI9341 driver chip
#include <limits.h>
#include "media/Free_Fonts.h" #include "media/Free_Fonts.h"
#include "media/images.h" #include "media/images.h"
#include "mbedtls/md.h" #include "mbedtls/md.h"
@ -12,7 +11,6 @@
#include "mining.h" #include "mining.h"
#define TARGET_BUFFER_SIZE 64 #define TARGET_BUFFER_SIZE 64
#define BUFFER_JSON_DOC 1024
unsigned long templates = 0; unsigned long templates = 0;
unsigned long hashes= 0; unsigned long hashes= 0;
@ -31,6 +29,8 @@ extern char btcString[80];
extern OpenFontRender render; extern OpenFontRender render;
extern TFT_eSprite background; extern TFT_eSprite background;
bool checkValid(unsigned char* hash, unsigned char* target) { bool checkValid(unsigned char* hash, unsigned char* target) {
bool valid = true; bool valid = true;
for(uint8_t i=31; i>=0; i--) { for(uint8_t i=31; i>=0; i--) {
@ -42,7 +42,7 @@ bool checkValid(unsigned char* hash, unsigned char* target) {
break; break;
} }
} }
#ifdef DEBUG_MINING_SHARE #ifdef DEBUG_MINING
if (valid) { if (valid) {
Serial.print("\tvalid : "); Serial.print("\tvalid : ");
for (size_t i = 0; i < 32; i++) for (size_t i = 0; i < 32; i++)
@ -87,55 +87,21 @@ bool verifyPayload (String line){
return true; return true;
} }
unsigned long getNextId(unsigned long id) {
if (id == ULONG_MAX) {
id = 1;
return id;
}
return ++id;
}
void getNextExtranonce2(int extranonce2_size, char *extranonce2) {
unsigned long extranonce2_number = strtoul(extranonce2, NULL, 10);
extranonce2_number++;
memset(extranonce2, '0', 2 * extranonce2_size);
if (extranonce2_number > long(pow(10, 2 * extranonce2_size))) {
return;
}
char next_extranounce2[2 * extranonce2_size + 1];
memset(extranonce2, '0', 2 * extranonce2_size);
ultoa(extranonce2_number, next_extranounce2, 10);
memcpy(extranonce2 + (2 * extranonce2_size) - long(log10(extranonce2_number)) - 1 , next_extranounce2, strlen(next_extranounce2));
extranonce2[2 * extranonce2_size] = 0;
}
bool checkError(const StaticJsonDocument<BUFFER_JSON_DOC> doc) {
if (doc["error"].size() == 0) {
return false;
}
Serial.printf("ERROR: %d | reason: %s \n", (const int) doc["error"][0], (const char*) doc["error"][1]);
return true;
}
void runWorker(void *name) { void runWorker(void *name) {
// TEST: https://bitcoin.stackexchange.com/questions/22929/full-example-data-for-scrypt-stratum-client // TEST: https://bitcoin.stackexchange.com/questions/22929/full-example-data-for-scrypt-stratum-client
Serial.println(""); Serial.println("");
Serial.printf("\n[WORKER] Started. Running %s on core %d\n", (char *)name, xPortGetCoreID()); Serial.printf("\n[WORKER] Started. Running %s on core %d\n", (char *)name, xPortGetCoreID());
#ifdef DEBUG_MEMORY
Serial.printf("### [Total Heap / Free heap]: %d / %d \n", ESP.getHeapSize(), ESP.getFreeHeap()); Serial.printf("### [Total Heap / Free heap]: %d / %d \n", ESP.getHeapSize(), ESP.getFreeHeap());
#endif
String ADDRESS = String(btcString);
// connect to pool // connect to pool
WiFiClient client; WiFiClient client;
bool continueSecuence = false; bool continueSecuence = false;
String line, extranonce1, extranonce2 = String("0"); String line, extranonce1;
unsigned long id = 0, extranonce_number = 0; unsigned long id = 1;
unsigned int extranonce2_size; unsigned int extranonce2_size;
while(true) { while(true) {
@ -143,47 +109,54 @@ void runWorker(void *name) {
if(WiFi.status() != WL_CONNECTED) continue; if(WiFi.status() != WL_CONNECTED) continue;
// get template // get template
StaticJsonDocument<BUFFER_JSON_DOC> doc; DynamicJsonDocument doc(4 * 1024);
String payload;
char payload[BUFFER_JSON_DOC] = {0};
if (!client.connect(poolString, portNumber)) { if (!client.connect(poolString, portNumber)) {
continue; continue;
} }
// STEP 1: Pool server connection (SUBSCRIBE) // STEP 1: Pool server connection
// Docs: payload = "{\"id\": "+ String(id++) +", \"method\": \"mining.subscribe\", \"params\": [\"" + ADDRESS + "\", \"password\"]}\n";
// - https://cs.braiins.com/stratum-v1/docs
// - https://github.com/aeternity/protocol/blob/master/STRATUM.md#mining-subscribe
id = getNextId(id);
sprintf(payload, "{\"id\": %u, \"method\": \"mining.subscribe\", \"params\": [\"NerdMinerV2\"]}\n", id);
Serial.printf("[WORKER] %s ==> Mining subscribe\n", (char *)name); Serial.printf("[WORKER] %s ==> Mining subscribe\n", (char *)name);
Serial.print(" Sending : "); Serial.println(payload); Serial.print(" Sending : "); Serial.println(payload);
client.print(payload); client.print(payload.c_str());
line = client.readStringUntil('\n'); line = client.readStringUntil('\n');
if(!verifyPayload(line)) return; if(!verifyPayload(line)) return;
Serial.print(" Receiving: "); Serial.println(line); Serial.print(" Receiving: "); Serial.println(line);
deserializeJson(doc, line); deserializeJson(doc, line);
if (checkError(doc)) { int error = doc["error"];
Serial.printf("[WORKER] %s >>>>>>>>> Work aborted\n", (char *)name);
continue;
}
String sub_details = String((const char*) doc["result"][0][0][1]); String sub_details = String((const char*) doc["result"][0][0][1]);
extranonce1 = String((const char*) doc["result"][1]); extranonce1 = String((const char*) doc["result"][1]);
int extranonce2_size = doc["result"][2]; int extranonce2_size = doc["result"][2];
// DIFFICULTY // DIFFICULTY
line = client.readStringUntil('\n'); line = client.readStringUntil('\n');
Serial.print(" Receiving: "); Serial.println(line);
Serial.print(" sub_details: "); Serial.println(sub_details); Serial.print(" sub_details: "); Serial.println(sub_details);
Serial.print(" extranonce1: "); Serial.println(extranonce1); Serial.print(" extranonce1: "); Serial.println(extranonce1);
Serial.print(" extranonce2_size: "); Serial.println(extranonce2_size); Serial.print(" extranonce2_size: "); Serial.println(extranonce2_size);
Serial.print(" error: "); Serial.println(error);
if((extranonce1.length() == 0) || line.length() == 0 || (error != 0)) {
Serial.printf("[WORKER] %s >>>>>>>>> Work aborted\n", (char *)name);
Serial.printf("extranonce1 length: %u | line2 length: %u | error code: %u \n", extranonce1.length(), line.length(), error);
client.stop();
doc.clear();
doc.garbageCollect();
continue;
}
// Recibe Work // STEP 2: Pool authorize work
//line = "{\"params\": [\"b3ba\", \"7dcf1304b04e79024066cd9481aa464e2fe17966e19edf6f33970e1fe0b60277\", \"01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff270362f401062f503253482f049b8f175308\", \"0d2f7374726174756d506f6f6c2f000000000100868591052100001976a91431482118f1d7504daf1c001cbfaf91ad580d176d88ac00000000\", [\"57351e8569cb9d036187a79fd1844fd930c1309efcd16c46af9bb9713b6ee734\", \"936ab9c33420f187acae660fcdb07ffdffa081273674f0f41e6ecc1347451d23\"], \"00000002\", \"1b44dfdb\", \"53178f9b\", true], \"id\": null, \"method\": \"mining.notify\"}"; payload = "{\"params\": [\"" + ADDRESS + "\", \"password\"], \"id\": "+ String(id++) +", \"method\": \"mining.authorize\"}\n";
Serial.printf("[WORKER] %s ==> Autorize work\n", (char *)name);
Serial.print(" Sending : "); Serial.println(payload);
client.print(payload.c_str());
line = client.readStringUntil('\n'); line = client.readStringUntil('\n');
doc.clear(); if(!verifyPayload(line)) return;
Serial.print(" Receiving: "); Serial.println(line);
Serial.print(" Receiving: "); Serial.println(client.readStringUntil('\n'));
Serial.print(" Receiving: "); Serial.println(client.readStringUntil('\n'));
client.stop();
deserializeJson(doc, line); deserializeJson(doc, line);
Serial.print("doc size: "); Serial.println(doc.size());
String job_id = String((const char*) doc["params"][0]); String job_id = String((const char*) doc["params"][0]);
String prevhash = String((const char*) doc["params"][1]); String prevhash = String((const char*) doc["params"][1]);
String coinb1 = String((const char*) doc["params"][2]); String coinb1 = String((const char*) doc["params"][2]);
@ -194,28 +167,6 @@ void runWorker(void *name) {
String ntime = String((const char*) doc["params"][7]); String ntime = String((const char*) doc["params"][7]);
bool clean_jobs = doc["params"][8]; //bool bool clean_jobs = doc["params"][8]; //bool
if((extranonce1.length() == 0) || line.length() == 0) {
Serial.printf("[WORKER] %s >>>>>>>>> Work aborted\n", (char *)name);
Serial.printf("extranonce1 length: %u | line2 length: %u \n", extranonce1.length(), line.length());
client.stop();
doc.clear();
doc.garbageCollect();
continue;
}
// STEP 2: Pool authorize work (Block Info)
id = getNextId(id);
sprintf(payload, "{\"params\": [\"%s\", \"x\"], \"id\": %u, \"method\": \"mining.authorize\"}\n",
btcString,
id);
Serial.printf("[WORKER] %s ==> Autorize work\n", (char *)name);
Serial.print(" Sending : "); Serial.println(payload);
client.print(payload);
line = client.readStringUntil('\n');
if(!verifyPayload(line)) return;
Serial.print(" Receiving: "); Serial.println(line);
client.stop();
#ifdef DEBUG_MINING #ifdef DEBUG_MINING
Serial.print(" job_id: "); Serial.println(job_id); Serial.print(" job_id: "); Serial.println(job_id);
Serial.print(" prevhash: "); Serial.println(prevhash); Serial.print(" prevhash: "); Serial.println(prevhash);
@ -232,6 +183,7 @@ void runWorker(void *name) {
Serial.println(">>>>>>>>> Worker aborted"); Serial.println(">>>>>>>>> Worker aborted");
client.stop(); client.stop();
doc.clear(); doc.clear();
doc.garbageCollect();
continue; continue;
} }
@ -244,7 +196,7 @@ void runWorker(void *name) {
memset(target, '0', TARGET_BUFFER_SIZE); memset(target, '0', TARGET_BUFFER_SIZE);
int zeros = (int) strtol(nbits.substring(0, 2).c_str(), 0, 16) - 3; int zeros = (int) strtol(nbits.substring(0, 2).c_str(), 0, 16) - 3;
memcpy(target + zeros - 2, nbits.substring(2).c_str(), nbits.length() - 2); memcpy(target + zeros - 2, nbits.substring(2).c_str(), nbits.length() - 2);
target[TARGET_BUFFER_SIZE] = 0; target[TARGET_BUFFER_SIZE+1] = 0;
Serial.print(" target: "); Serial.println(target); Serial.print(" target: "); Serial.println(target);
// bytearray target // bytearray target
uint8_t bytearray_target[32]; uint8_t bytearray_target[32];
@ -262,15 +214,30 @@ void runWorker(void *name) {
} }
// get extranonce2 - extranonce2 = hex(random.randint(0,2**32-1))[2:].zfill(2*extranonce2_size) // get extranonce2 - extranonce2 = hex(random.randint(0,2**32-1))[2:].zfill(2*extranonce2_size)
char extranonce2_char[2 * extranonce2_size+1]; uint32_t extranonce2_a_bin = esp_random();
extranonce2.toCharArray(extranonce2_char, 2 * extranonce2_size + 1); uint32_t extranonce2_b_bin = esp_random();
getNextExtranonce2(extranonce2_size, extranonce2_char); String extranonce2_a = String(extranonce2_a_bin, HEX);
//extranonce2 = String(extranonce2_char); String extranonce2_b = String(extranonce2_b_bin, HEX);
extranonce2 = "00000002"; uint8_t pad = 8 - extranonce2_a.length();
char extranonce2_a_char[pad+1];
for (int k = 0; k < pad; k++) {
extranonce2_a_char[k] = '0';
}
extranonce2_a_char[pad+1] = 0;
extranonce2_a = String(extranonce2_a_char) + extranonce2_a;
pad = 8 - extranonce2_b.length();
char extranonce2_b_char[pad+1];
for (int k = 0; k < pad; k++) {
extranonce2_b_char[k] = '0';
}
extranonce2_b_char[pad+1] = 0;
extranonce2_b = String(extranonce2_b_char) + extranonce2_b;
String extranonce2 = String(extranonce2_a + extranonce2_b).substring(0, 17 - (2 * extranonce2_size));
//get coinbase - coinbase_hash_bin = hashlib.sha256(hashlib.sha256(binascii.unhexlify(coinbase)).digest()).digest() //get coinbase - coinbase_hash_bin = hashlib.sha256(hashlib.sha256(binascii.unhexlify(coinbase)).digest()).digest()
String coinbase = coinb1 + extranonce1 + extranonce2 + coinb2; String coinbase = coinb1 + extranonce1 + extranonce2 + coinb2;
Serial.print(" coinbase: "); Serial.println(coinbase);
size_t str_len = coinbase.length()/2; size_t str_len = coinbase.length()/2;
uint8_t bytearray[str_len]; uint8_t bytearray[str_len];
@ -281,7 +248,7 @@ void runWorker(void *name) {
Serial.print(" coinbase: "); Serial.println(coinbase); Serial.print(" coinbase: "); Serial.println(coinbase);
Serial.print(" coinbase bytes - size: "); Serial.println(res); Serial.print(" coinbase bytes - size: "); Serial.println(res);
for (size_t i = 0; i < res; i++) for (size_t i = 0; i < res; i++)
Serial.printf("%02x", bytearray[i]); Serial.printf("%02x ", bytearray[i]);
Serial.println("---"); Serial.println("---");
#endif #endif
@ -312,7 +279,7 @@ void runWorker(void *name) {
memcpy(merkle_result, shaResult, sizeof(shaResult)); memcpy(merkle_result, shaResult, sizeof(shaResult));
byte merkle_concatenated[32 * 2]; byte merkle_concatenated[32 * 2];
for (size_t k=0; k < merkle_branch.size(); k++) { for (size_t k=0; k<merkle_branch.size(); k++) {
const char* merkle_element = (const char*) merkle_branch[k]; const char* merkle_element = (const char*) merkle_branch[k];
uint8_t bytearray[32]; uint8_t bytearray[32];
size_t res = to_byte_array(merkle_element, 64, bytearray); size_t res = to_byte_array(merkle_element, 64, bytearray);
@ -363,8 +330,7 @@ void runWorker(void *name) {
Serial.println(""); Serial.println("");
// calculate blockheader // calculate blockheader
// j.block_header = ''.join([j.version, j.prevhash, merkle_root, j.ntime, j.nbits]) String blockheader = version + prevhash + String(merkle_root) + nbits + ntime + "00000000";
String blockheader = version + prevhash + String(merkle_root) + ntime + nbits + "00000000";
str_len = blockheader.length()/2; str_len = blockheader.length()/2;
uint8_t bytearray_blockheader[str_len]; uint8_t bytearray_blockheader[str_len];
res = to_byte_array(blockheader.c_str(), str_len*2, bytearray_blockheader); res = to_byte_array(blockheader.c_str(), str_len*2, bytearray_blockheader);
@ -407,35 +373,30 @@ void runWorker(void *name) {
for (size_t i = 0; i < 4; i++) for (size_t i = 0; i < 4; i++)
Serial.printf("%02x", bytearray_blockheader[i]); Serial.printf("%02x", bytearray_blockheader[i]);
Serial.println(""); Serial.println("");
Serial.print("version "); Serial.println("version");
for (size_t i = 0; i < 4; i++) for (size_t i = 0; i < 4; i++)
Serial.printf("%02x", bytearray_blockheader[i]); Serial.printf("%02x", bytearray_blockheader[i]);
Serial.println(""); Serial.println("");
Serial.print("prev hash "); Serial.println("prev hash");
for (size_t i = 4; i < 4+32; i++) for (size_t i = 4; i < 4+32; i++)
Serial.printf("%02x", bytearray_blockheader[i]); Serial.printf("%02x", bytearray_blockheader[i]);
Serial.println(""); Serial.println("");
Serial.print("merkle root "); Serial.println("merkle root");
for (size_t i = 36; i < 36+32; i++) for (size_t i = 36; i < 36+32; i++)
Serial.printf("%02x", bytearray_blockheader[i]); Serial.printf("%02x", bytearray_blockheader[i]);
Serial.println(""); Serial.println("");
Serial.print("nbits "); Serial.println("time");
for (size_t i = 68; i < 68+4; i++) for (size_t i = 68; i < 68+4; i++)
Serial.printf("%02x", bytearray_blockheader[i]); Serial.printf("%02x", bytearray_blockheader[i]);
Serial.println(""); Serial.println("");
Serial.print("difficulty "); Serial.println("difficulty");
for (size_t i = 72; i < 72+4; i++) for (size_t i = 72; i < 72+4; i++)
Serial.printf("%02x", bytearray_blockheader[i]); Serial.printf("%02x", bytearray_blockheader[i]);
Serial.println(""); Serial.println("");
Serial.print("nonce "); Serial.println("nonce");
for (size_t i = 76; i < 76+4; i++) for (size_t i = 76; i < 76+4; i++)
Serial.printf("%02x", bytearray_blockheader[i]); Serial.printf("%02x", bytearray_blockheader[i]);
Serial.println(""); Serial.println("");
Serial.println("bytearray_blockheader: ");
for (size_t i = 0; i < str_len; i++) {
Serial.printf("%02x", bytearray_blockheader[i]);
}
Serial.println("");
#endif #endif
mbedtls_sha256_context midstate[32]; mbedtls_sha256_context midstate[32];
@ -448,8 +409,7 @@ void runWorker(void *name) {
// search a valid nonce // search a valid nonce
enableGlobalHash = true; enableGlobalHash = true;
uint32_t nonce = 0;
unsigned long nonce = TARGET_NONCE - MAX_NONCE;
uint32_t startT = micros(); uint32_t startT = micros();
unsigned char *header64 = bytearray_blockheader + 64; unsigned char *header64 = bytearray_blockheader + 64;
Serial.println(">>> STARTING TO HASH NONCES"); Serial.println(">>> STARTING TO HASH NONCES");
@ -484,7 +444,7 @@ void runWorker(void *name) {
Serial.println(""); */ Serial.println(""); */
hashes++; hashes++;
if (nonce++> TARGET_NONCE) break; //exit if (nonce++> MAX_NONCE) break; //exit
// check if 16bit share // check if 16bit share
if(hash[31]!=0) continue; if(hash[31]!=0) continue;
@ -497,30 +457,24 @@ void runWorker(void *name) {
// check if valid header // check if valid header
if(checkValid(hash, bytearray_target)){ if(checkValid(hash, bytearray_target)){
Serial.printf("[WORKER] %s CONGRATULATIONS! Valid completed with nonce: %d | 0x%x\n", (char *)name, nonce, nonce); //Serial.printf("%s on core %d: ", (char *)name, xPortGetCoreID());
valids++; Serial.printf("[WORKER] %s CONGRATULATIONS! Valid completed with nonce: %d | 0x%x\n", (char *)name, nonce, nonce);
Serial.printf("[WORKER] %s Submiting work valid!\n", (char *)name); valids++;
while (!client.connected()) { Serial.printf("[WORKER] %s Submiting work valid!\n", (char *)name);
client.connect(poolString, portNumber); while (!client.connected()) {
vTaskDelay(1000 / portTICK_PERIOD_MS); client.connect(poolString, portNumber);
} vTaskDelay(1000 / portTICK_PERIOD_MS);
// STEP 3: Submit mining job }
id = getNextId(id); // STEP 3: Submit mining job
sprintf(payload, "{\"params\": [\"%s\",\"%s\",\"%s\",\"%s\",\"%s\"], \"id\": %u, \"method\": \"mining.submit\"}", payload = "{\"params\": [\"" + ADDRESS + "\", \"" + job_id + "\", \"" + extranonce2 + "\", \"" + ntime + "\", \"" + String(nonce, HEX) + "\"], \"id\": "+ String(id++) +", \"method\": \"mining.submit\"}";
btcString, Serial.print(" Sending : "); Serial.println(payload);
job_id, client.print(payload.c_str());
extranonce2, line = client.readStringUntil('\n');
ntime, Serial.print(" Receiving: "); Serial.println(line);
String(nonce, HEX), client.stop();
id // exit
); nonce = MAX_NONCE;
Serial.print(" Sending : "); Serial.println(payload); break;
client.print(payload);
Serial.print(" Receiving: "); Serial.println(client.readString());
client.stop();
// exit
nonce = MAX_NONCE;
break;
} }
} // exit if found a valid result or nonce > MAX_NONCE } // exit if found a valid result or nonce > MAX_NONCE
@ -528,31 +482,22 @@ void runWorker(void *name) {
mbedtls_sha256_free(midstate); mbedtls_sha256_free(midstate);
enableGlobalHash = false; enableGlobalHash = false;
// TODO Pending doub
if(hashes>=MAX_NONCE) { Mhashes=Mhashes+MAX_NONCE/1000000; hashes=hashes-MAX_NONCE;} if(hashes>=MAX_NONCE) { Mhashes=Mhashes+MAX_NONCE/1000000; hashes=hashes-MAX_NONCE;}
if (nonce == TARGET_NONCE) { if (nonce == MAX_NONCE) {
Serial.printf("[WORKER] %s SUBMITING WORK... MAX Nonce reached > MAX_NONCE\n", (char *)name); Serial.printf("[WORKER] %s SUBMITING WORK... MAX Nonce reached > MAX_NONCE\n", (char *)name);
// STEP 3: Submit mining job // STEP 3: Submit mining job
id = getNextId(id);
if (client.connect(poolString, portNumber)) { if (client.connect(poolString, portNumber)) {
sprintf(payload, "{\"params\": [\"%s\",\"%s\",\"%s\",\"%s\",\"%s\"], \"id\": %u, \"method\": \"mining.submit\"}", payload = "{\"params\": [\"" + ADDRESS + "\", \"" + job_id + "\", \"" + extranonce2 + "\", \"" + ntime + "\", \"" + String(nonce, HEX) + "\"], \"id\": "+ String(id++) +", \"method\": \"mining.submit\"}";
btcString,
job_id,
extranonce2,
ntime,
String(nonce, HEX),
id
);
Serial.print(" Sending : "); Serial.println(payload); Serial.print(" Sending : "); Serial.println(payload);
client.print(payload); client.print(payload.c_str());
unsigned long timeout = millis(); Serial.print(" Receiving: "); Serial.println(client.readStringUntil('\n'));
Serial.print(" Receiving: "); Serial.println(client.readString()); while (client.available()) {
Serial.printf("[WORKER] %s SUBMITED WORK\n", (char *)name); Serial.print(" Receiving: "); Serial.println(client.readStringUntil('\n'));
}
client.stop(); client.stop();
} }
} }
uint32_t duration = micros() - startT; uint32_t duration = micros() - startT;
} }
@ -560,10 +505,11 @@ void runWorker(void *name) {
//////////////////THREAD CALLS/////////////////// //////////////////THREAD CALLS///////////////////
//Testeamos hashrate final usando hilo principal //Testeamos hashrate final usando hilo principal
//this is currently on test //this is currently on test
void runMiner(void) { void runMiner(void){
uint32_t nonce=0; uint32_t nonce=0;
unsigned char bytearray_blockheader[80]; unsigned char bytearray_blockheader[80];
@ -580,7 +526,7 @@ void runMiner(void) {
//Iteraciones //Iteraciones
unsigned char *header64 = bytearray_blockheader + 64; unsigned char *header64 = bytearray_blockheader + 64;
for(nonce = 0; nonce < 10000; nonce++) { for(nonce = 0; nonce < 10000; nonce++){
memcpy(bytearray_blockheader + 77, &nonce, 3); memcpy(bytearray_blockheader + 77, &nonce, 3);
mbedtls_sha256_clone(&ctx, midstate); //Clonamos el contexto anterior para continuar el SHA desde allí mbedtls_sha256_clone(&ctx, midstate); //Clonamos el contexto anterior para continuar el SHA desde allí
mbedtls_sha256_update_ret(&ctx, header64, 16); mbedtls_sha256_update_ret(&ctx, header64, 16);
@ -599,7 +545,7 @@ void runMiner(void) {
} }
void runMonitor() { void runMonitor(void *name){
Serial.println("[MONITOR] started"); Serial.println("[MONITOR] started");
@ -610,9 +556,8 @@ void runMonitor() {
unsigned long mElapsed = millis()-mStart; unsigned long mElapsed = millis()-mStart;
unsigned long totalKHashes = (Mhashes*1000) + hashes/1000; unsigned long totalKHashes = (Mhashes*1000) + hashes/1000;
//Serial.println("[runMonitor Task] -> Printing results on screen "); //Serial.println("[runMonitor Task] -> Printing results on screen ");
Serial.printf(">>> Completed %d share(s), %d Khashes, avg. hashrate %.3f KH/s\n",
//Serial.printf(">>> Completed %d share(s), %d Khashes, avg. hashrate %.3f KH/s\n", shares, totalKHashes, (1.0*(totalKHashes*1000))/mElapsed);
// shares, totalKHashes, (1.0*(totalKHashes*1000))/mElapsed);
//Hashrate //Hashrate
render.setFontSize(70); render.setFontSize(70);
@ -654,6 +599,6 @@ void runMonitor() {
background.pushSprite(0,0); background.pushSprite(0,0);
// Pause the task for 5000ms // Pause the task for 5000ms
// vTaskDelay(5000 / portTICK_PERIOD_MS); vTaskDelay(5000 / portTICK_PERIOD_MS);
} }
} }

11
src/mining.h
View File

@ -1,9 +1,14 @@
// Mining // Mining
#define THREADS 1 #define THREADS 1
#define MAX_NONCE 5000000U #define MAX_NONCE 3000000
#define TARGET_NONCE 471136297U // #define MAX_NONCE 1.215.752.192
void runMonitor(); // Pool
//#define POOL_URL "solo.ckpool.org" //"btc.zsolo.bid" "eu.stratum.slushpool.com"
//#define POOL_PORT 3333 //6057 //3333
void runMonitor(void *name);
void runWorker(void *name); void runWorker(void *name);
void runMiner(void); void runMiner(void);