I2C issues using ATTiny88 MH-ET board (noob)

[RALEIGHthe3rd]

First off, I'm an idiot. I'm not a coder, and barely have enough knowledge to get things to work, given someone else has done it first. Sorry if I ask dumb questions. I try to research as much as possible, but sometimes I don't know the direction to be searching. Thank you in advance for helping me learn.

I am trying to use ATTiny88 as an I2C slave to mine Duino Coin. I'm using the code below, and things work well 70% of the time. Normally the master sends a job to the slave from a mining pool. The slave does "work" and returns a "hash" solution. Ultimately I want several slaves, but dealing with just one right now. My problem is that 20-30% of the jobs fail. The slave just returns 0s for the solution, which of course gets rejected. The time is ALWAYS the same, 2.84s on the failed jobs. Successful jobs are ALWAYS less than that amount of time. Not sure if there is a timing/timeout issue, or possible stack overflow? IDK

I2C is runiing at 100kHz, but also tried 400kHz without luck. Also tried the Attiny88 at 8MHz istead of 16, but no change, just slower. The master will be an ESP (32 or 8266 depending on performance), and I've tried both with the exact same result. I am using the ATTiny Core with the Micronucleus bootloader, and Wire.h. With LTO enabled, I have 32 bytes of memory left. Without LTO, -3 bits and failure to compile. Not sure if this is a clue. Also using a logic converter for the I2C bus, that has built in 10k resistors.

I appreciate any guidance or help. I am will to try and test whatever is needed.

This is the virgin code that has proven to work for many other devices.

/*
  DoinoCoin_Tiny_Slave.ino
  created 07 08 2021
  by Luiz H. Cassettari
*/

#include <ArduinoUniqueID.h>  // https://github.com/ricaun/ArduinoUniqueID
#include <EEPROM.h>
#include <Wire.h>
#include "sha1.h"

#if defined(ARDUINO_AVR_UNO) | defined(ARDUINO_AVR_PRO)
#define SERIAL_LOGGER Serial
#define LED LED_BUILTIN
#endif

// ATtiny85 - http://drazzy.com/package_drazzy.com_index.json
// SCL - PB2 - 2
// SDA - PB0 - 0

//#define FIND_I2C

#define ADDRESS_I2C 1
#define EEPROM_ADDRESS 0

#ifdef SERIAL_LOGGER
#define SerialBegin()              SERIAL_LOGGER.begin(115200);
#define SerialPrint(x)             SERIAL_LOGGER.print(x);
#define SerialPrintln(x)           SERIAL_LOGGER.println(x);
#else
#define SerialBegin()
#define SerialPrint(x)
#define SerialPrintln(x)
#endif

#ifdef LED
#define LedBegin()                pinMode(LED, OUTPUT);
#define LedHigh()                 digitalWrite(LED, HIGH);
#define LedLow()                  digitalWrite(LED, LOW);
#define LedBlink()                LedHigh(); delay(100); LedLow(); delay(100);
#else
#define LedBegin()
#define LedHigh()
#define LedLow()
#define LedBlink()
#endif

#define BUFFER_MAX 88
#define HASH_BUFFER_SIZE 20
#define CHAR_END '\n'
#define CHAR_DOT ','

static const char DUCOID[] PROGMEM = "DUCOID";
static const char ZEROS[] PROGMEM = "000";

static byte address;
static char buffer[BUFFER_MAX];
static uint8_t buffer_position;
static uint8_t buffer_length;
static bool working;
static bool jobdone;


void(* resetFunc) (void) = 0;//declare reset function at address 0

// --------------------------------------------------------------------- //
// setup
// --------------------------------------------------------------------- //

void setup() {
  SerialBegin();
  initialize_i2c();
  LedBegin();
  LedBlink();
  LedBlink();
  LedBlink();
}

// --------------------------------------------------------------------- //
// loop
// --------------------------------------------------------------------- //

void loop() {
  do_work();
  millis(); // ????? For some reason need this to work the i2c
#ifdef SERIAL_LOGGER
  if (SERIAL_LOGGER.available())
  {
#ifdef EEPROM_ADDRESS
    EEPROM.write(EEPROM_ADDRESS, SERIAL_LOGGER.parseInt());
#endif
    resetFunc();
  }
#endif
}

// --------------------------------------------------------------------- //
// run
// --------------------------------------------------------------------- //

boolean runEvery(unsigned long interval)
{
  static unsigned long previousMillis = 0;
  unsigned long currentMillis = millis();
  if (currentMillis - previousMillis >= interval)
  {
    previousMillis = currentMillis;
    return true;
  }
  return false;
}

// --------------------------------------------------------------------- //
// work
// --------------------------------------------------------------------- //

void do_work()
{
  if (working)
  {
    LedHigh();
    SerialPrintln(buffer);

    if (buffer[0] == '#')
    {
      resetFunc();
    }

#ifdef FIND_I2C
    if (buffer[0] == '@')
    {
      address = find_i2c();
      memset(buffer, 0, sizeof(buffer));
      buffer_position = 0;
      buffer_length = 0;
      working = false;
      jobdone = false;
      return;
    }
#endif

    do_job();
  }
  LedLow();
}

void do_job()
{
  unsigned long startTime = millis();
  int job = work();
  unsigned long endTime = millis();
  unsigned int elapsedTime = endTime - startTime;
  memset(buffer, 0, sizeof(buffer));
  char cstr[16];

  // Job
  itoa(job, cstr, 10);
  strcpy(buffer, cstr);
  buffer[strlen(buffer)] = CHAR_DOT;

  // Time
  itoa(elapsedTime, cstr, 10);
  strcpy(buffer + strlen(buffer), cstr);
  strcpy_P(buffer + strlen(buffer), ZEROS);
  buffer[strlen(buffer)] = CHAR_DOT;

  // DUCOID
  strcpy_P(buffer + strlen(buffer), DUCOID);
  for (size_t i = 0; i < 8; i++)
  {
    itoa(UniqueID8[i], cstr, 16);
    if (UniqueID8[i] < 16) strcpy(buffer + strlen(buffer), "0");
    strcpy(buffer + strlen(buffer), cstr);
  }

  SerialPrintln(buffer);

  buffer_position = 0;
  buffer_length = strlen(buffer);
  working = false;
  jobdone = true;
}

int work()
{
  char delimiters[] = ",";
  char *lastHash = strtok(buffer, delimiters);
  char *newHash = strtok(NULL, delimiters);
  char *diff = strtok(NULL, delimiters);
  buffer_length = 0;
  buffer_position = 0;
  return work(lastHash, newHash, atoi(diff));
}

//#define HTOI(c) ((c<='9')?(c-'0'):((c<='F')?(c-'A'+10):((c<='f')?(c-'a'+10):(0))))
#define HTOI(c) ((c<='9')?(c-'0'):((c<='f')?(c-'a'+10):(0)))
#define TWO_HTOI(h, l) ((HTOI(h) << 4) + HTOI(l))
//byte HTOI(char c) {return ((c<='9')?(c-'0'):((c<='f')?(c-'a'+10):(0)));}
//byte TWO_HTOI(char h, char l) {return ((HTOI(h) << 4) + HTOI(l));}

void HEX_TO_BYTE(char * address, char * hex, int len)
{
  for (int i = 0; i < len; i++) address[i] = TWO_HTOI(hex[2 * i], hex[2 * i + 1]);
}

// DUCO-S1A hasher
uint32_t work(char * lastblockhash, char * newblockhash, int difficulty)
{
  if (difficulty > 655) return 0;
  HEX_TO_BYTE(newblockhash, newblockhash, HASH_BUFFER_SIZE);
  for (int ducos1res = 0; ducos1res < difficulty * 100 + 1; ducos1res++)
  {
    Sha1.init();
    Sha1.print(lastblockhash);
    Sha1.print(ducos1res);
    if (memcmp(Sha1.result(), newblockhash, HASH_BUFFER_SIZE) == 0)
    {
      return ducos1res;
    }
  }
  return 0;
}

// --------------------------------------------------------------------- //
// i2c
// --------------------------------------------------------------------- //

void initialize_i2c(void) {
  address = ADDRESS_I2C;

#ifdef EEPROM_ADDRESS
  address = EEPROM.read(EEPROM_ADDRESS);
  if (address == 0 || address > 127) {
    address = ADDRESS_I2C;
    EEPROM.write(EEPROM_ADDRESS, address);
  }
#endif

  SerialPrint("Wire begin ");
  SerialPrintln(address);
  Wire.begin(address);
  Wire.onReceive(onReceiveJob);
  Wire.onRequest(onRequestResult);
}

void onReceiveJob(int howMany) {
  if (howMany == 0) return;
  if (working) return;
  if (jobdone) return;

  while (Wire.available()) {
    char c = Wire.read();
    buffer[buffer_length++] = c;
    if (buffer_length == BUFFER_MAX) buffer_length--;
    if (c == CHAR_END)
    {
      working = true;
    }
  }
}

void onRequestResult() {
  char c = CHAR_END;
  if (jobdone) {
    c = buffer[buffer_position++];
    if ( buffer_position == buffer_length) {
      jobdone = false;
      buffer_position = 0;
      buffer_length = 0;
    }
  }
  Wire.write(c);
}

// --------------------------------------------------------------------- //
// find_i2c
// --------------------------------------------------------------------- //

#ifdef FIND_I2C

byte find_i2c()
{
  unsigned long time = (unsigned long) getTrueRotateRandomByte() * 1000 + (unsigned long) getTrueRotateRandomByte();
  delayMicroseconds(time);
  Wire.begin();
  int address;
  for (address = 1; address < 127; address++ )
  {
    Wire.beginTransmission(address);
    int error = Wire.endTransmission();
    if (error != 0)
    {
      break;
    }
  }
  Wire.begin(address);
  //Wire.end();
  return address;
}

// ---------------------------------------------------------------
// True Random Numbers
// https://gist.github.com/bloc97/b55f684d17edd8f50df8e918cbc00f94
// ---------------------------------------------------------------

#if defined(ARDUINO_AVR_PRO)
#define ANALOG_RANDOM A6
#else
#define ANALOG_RANDOM A1
#endif

const int waitTime = 16;

byte lastByte = 0;
byte leftStack = 0;
byte rightStack = 0;

byte rotate(byte b, int r) {
  return (b << r) | (b >> (8 - r));
}

void pushLeftStack(byte bitToPush) {
  leftStack = (leftStack << 1) ^ bitToPush ^ leftStack;
}

void pushRightStackRight(byte bitToPush) {
  rightStack = (rightStack >> 1) ^ (bitToPush << 7) ^ rightStack;
}

byte getTrueRotateRandomByte() {
  byte finalByte = 0;

  byte lastStack = leftStack ^ rightStack;

  for (int i = 0; i < 4; i++) {
    delayMicroseconds(waitTime);
    int leftBits = analogRead(ANALOG_RANDOM);

    delayMicroseconds(waitTime);
    int rightBits = analogRead(ANALOG_RANDOM);

    finalByte ^= rotate(leftBits, i);
    finalByte ^= rotate(rightBits, 7 - i);

    for (int j = 0; j < 8; j++) {
      byte leftBit = (leftBits >> j) & 1;
      byte rightBit = (rightBits >> j) & 1;

      if (leftBit != rightBit) {
        if (lastStack % 2 == 0) {
          pushLeftStack(leftBit);
        } else {
          pushRightStackRight(leftBit);
        }
      }
    }

  }
  lastByte ^= (lastByte >> 3) ^ (lastByte << 5) ^ (lastByte >> 4);
  lastByte ^= finalByte;

  return lastByte ^ leftStack ^ rightStack;
}

#endif

[SpenceKonde]

That all needs to be put into a single code block, preferably with code freshly pasted from the actual code being used.

Are you using the 2.0.0-dev codebase? I know I've fixed several I2C-related issues for 2.0.0 - it's just not quite ready for release because there are showstopping problems (largely related to the unusability of the code currently used on my other cores when applied to this one - and the sheer number of conditionally compiled blocks of code means that it is 100% mandatory to have automated testing before considering the software to be ready for release. But I don't really know how to make that happen.

[RALEIGHthe3rd]

Great, thank you for the help.

Installing 2.0.0 now.

[RALEIGHthe3rd]

How do I format for a code block? I tried the <> button for add code, ctrl +e , can't find the answer. Sorry. That is the code copied and pasted from my computer. Just meant "virgin" as not something I'd messed around with, always made a copy when changing something trying to troubleshoot.

I am using ATtiny 1.5.2. I will update to 2.0.0 in a few hours and let you know.

[sleemanj]

How do I format for a code block?

Start and end the code you want to paste with three backticks

```
 #define SOMETHING 1
 #define SOMETHINGELSE 2

 void someFunction() 
 { 
    Serial.println(SOMETHING+SOMETHINGELSE);
 }
```

https://docs.github.com/en/get-started/writing-on-github/working-with-advanced-formatting/creating-and-highlighting-code-blocks

[RALEIGHthe3rd]

Does it look right now?

[sleemanj]

Yes (in that it's formatted in a code block, the rest I leave to Spence).

[RALEIGHthe3rd]

First test on 2.0.0 returns the following. I saw DrAzzy mention the same or similar issue on Arduino forums, but I didn't see or understand the solution. I manually deleted the previous version from Arduino15/packages folder and installed 2.0.0 in mydocuments/Arduino/hardware, maybe that was the wrong process? 2.0.0 doesn't show in my boards manager.

Arduino: 1.8.19 (Windows 10), Board: "ATtiny88 w/Micronucleus (MH-Tiny/MHET), -Os (size, recommended), 16 MHz (external clock), MH-Tiny, RX on PD7, TX on PD (default PD6), B.O.D. Disabled (saves power), Enabled, External Reset and Power On Reset, MH Tiny - PD1: D-, PD2: D+, PD0: LED, Reset pin. Further ISP programming possible, Upgrade (via USB)"

C:\Program Files (x86)\Arduino\arduino-builder -dump-prefs -logger=machine -hardware C:\Program Files (x86)\Arduino\hardware -hardware C:\Users\ralei\AppData\Local\Arduino15\packages -hardware C:\Users\ralei\OneDrive\Documents\Arduino\hardware -tools C:\Program Files (x86)\Arduino\tools-builder -tools C:\Program Files (x86)\Arduino\hardware\tools\avr -tools C:\Users\ralei\AppData\Local\Arduino15\packages -built-in-libraries C:\Program Files (x86)\Arduino\libraries -libraries C:\Users\ralei\OneDrive\Documents\Arduino\libraries -fqbn=ATTinyCore-2.0.0-dev:avr:attiny88micr:optimization=size,clock=extclk_16m,pinmap=mhet,softserial=enable,bod=disable,millis=enabled,bootentry=extrf_porf,usbpins=standard,resetpin=reset,burnmode=upgrade -ide-version=10819 -build-path C:\Users\ralei\AppData\Local\Temp\arduino_build_340606 -warnings=none -build-cache C:\Users\ralei\AppData\Local\Temp\arduino_cache_867644 -prefs=build.warn_data_percentage=75 -verbose C:\Users\ralei\Downloads\DuinoCoinI2C-main (ricaun)\DuinoCoinI2C-main\DuinoCoin_Tiny_Slave\DuinoCoin_Tiny_Slave.ino

panic: no major version found



goroutine 1 [running]:

go.bug.st/relaxed-semver.MustParse(...)

	/home/jenkins/go/pkg/mod/go.bug.st/[email protected]/parser.go:19

github.com/arduino/arduino-cli/arduino/cores/packagemanager.(*PackageManager).loadPlatforms(0x12444d60, 0x125a68c0, 0x128f45a0, 0x14, 0x128f0678)

	/home/jenkins/go/pkg/mod/github.com/arduino/[email protected]/arduino/cores/packagemanager/loader.go:175 +0x14f6

github.com/arduino/arduino-cli/arduino/cores/packagemanager.(*PackageManager).LoadHardwareFromDirectory(0x12444d60, 0x128f4318, 0x0, 0x0)

	/home/jenkins/go/pkg/mod/github.com/arduino/[email protected]/arduino/cores/packagemanager/loader.go:120 +0x42b

github.com/arduino/arduino-cli/arduino/cores/packagemanager.(*PackageManager).LoadHardwareFromDirectories(0x12444d60, 0x12404d00, 0x3, 0x4, 0x4, 0xcb63b2)

	/home/jenkins/go/pkg/mod/github.com/arduino/[email protected]/arduino/cores/packagemanager/loader.go:45 +0x4f

github.com/arduino/arduino-cli/legacy/builder.(*HardwareLoader).Run(0x13db448, 0x1240a000, 0x13db448, 0x0)

	/home/jenkins/go/pkg/mod/github.com/arduino/[email protected]/legacy/builder/hardware_loader.go:29 +0x150

github.com/arduino/arduino-cli/legacy/builder.(*ContainerSetupHardwareToolsLibsSketchAndProps).Run(0x13db448, 0x1240a000, 0x0, 0x0)

	/home/jenkins/go/pkg/mod/github.com/arduino/[email protected]/legacy/builder/container_setup.go:50 +0x2b1

github.com/arduino/arduino-cli/legacy/builder.runCommands(0x1240a000, 0x1243fee8, 0x2, 0x2, 0x0, 0x0)

	/home/jenkins/go/pkg/mod/github.com/arduino/[email protected]/legacy/builder/builder.go:191 +0x198

github.com/arduino/arduino-cli/legacy/builder.(*ParseHardwareAndDumpBuildProperties).Run(0x128a9f26, 0x1240a000, 0x13db380, 0x128f43a0)

	/home/jenkins/go/pkg/mod/github.com/arduino/[email protected]/legacy/builder/builder.go:182 +0x8f

github.com/arduino/arduino-cli/legacy/builder.RunParseHardwareAndDumpBuildProperties(...)

	/home/jenkins/go/pkg/mod/github.com/arduino/[email protected]/legacy/builder/builder.go:214

main.main()

	/home/jenkins/workspace/arduino-builder-all-cross-cli-inception/main.go:391 +0x7de

C:\Program Files (x86)\Arduino\arduino-builder returned 2



Error compiling for board ATtiny88 w/Micronucleus (MH-Tiny/MHET).

[RALEIGHthe3rd]

Figured that error out. changed /ATTinyCore/avr/platform.txt to "version=2.0.0" and removed the other version info at the start of that file. Compiles fine now.

[RALEIGHthe3rd]

So after update to 2.0.0-dev, I have exactly the same result. Any mining "job" that is returned to the master in less than 2.84 seconds is accepted, but as soon as 2.84s hits, the slave returns all zeros for the solution and the job is rejected.

[SpenceKonde]

Interesting, will look into this

[SpenceKonde]

Oh - very important quation - you say that code has worked on other parts. Could you share a list of exactlt which parts that is?
Namely:

• Does it work on tiny 84? (same RAM, same flash, same gimped I2C (USI rather than I2C))
• Not sure if different I2C speeds are supported by universal Wire.h on parts with USI. Almost certain not supported as master.

The LTO difference is not a clue, other than pointing to the LTO producing pathetically poor flash savigns with that sketch for some reason. LTO sometimes produces huge savings. Other times very little.

Make sure that analog channel 1 is not used for something else.

ADC channels are a generally poor source of randomness, even if floating. Sticking a longer wire/rrace on it will help, but what I'd do is grab something like my xorshift RNG, only get a random ADC value to seed it once, and then gener the randomd numbers from the xorshift rng, which generates 16-bit random numbers much faster. It's written in inline assembly and generally screams. Works on any AVR, classic or modern

[RALEIGHthe3rd]

• Not sure if anyone is using the 84, some are using the 85 and Trinket specifically, but I know they use TinyWire libraries. I asked our Discord community if anyone is using the 84. I'm in contact with the developer on Discord as well. I thought the 48/88 has "full hardware I2C" and doesn't use USI? (I think I learned that from your readme.md)
• I think I saw somewhere that 400k speed was supported, and thought it was something to try. Don't think it's important, but IDK, just something I tried.

Nothing is using analog 1 (that I could find). Also, the random number generator is part of "#ifdef FIND_I2C" and I don't have that enabled. I'm manually addressing the slaves. Good to know about the better way for randomness. I appreciate the lesson.

[SpenceKonde]

OH SHIT! You're right! It does have full hardware I2C! So it should work fine......

[RALEIGHthe3rd]

Hmmmmm, ok. I will return to the developer with that info and see if we can get 'er working. Thank you so much for taking the time to help, and for all of you development and documentation. I've learned a lot from you during this project. If you have any other suggestions for trials let me know. I will reach out the the developer of the code and see if he has an ideas from here.

Also, 2.0.0-dev seems to work flawlessly since I changed. I am happy to test anything that you might need, you'll just have to tolerate my ignorance along the way, lol. Right now I have a bunch of MH-ET boards laying around.

[SpenceKonde]

One thing that would be very interesting Is to hear what core and version people are using on other chips with success (avrs only)

…

____________ Spence Konde Azzy’S Electronics New products! Check them out at tindie.com/stores/DrAzzy GitHub: github.com/SpenceKonde ATTinyCore: Arduino support for almost every ATTiny microcontroller Contact: ***@***.***

On Fri, May 13, 2022, 14:42 RALEIGHthe3rd ***@***.***> wrote: Hmmmmm, ok. I will return to the developer with that info and see if we can get 'er working. Thank you so much for taking the time to help, and for all of you development and documentation. I've learned a lot from you during this project. If you have any other suggestions for trials let me know. I will reach out the the developer of the code and see if he has an ideas from here. Also, 2.0.0-dev seems to work flawlessly since I changed. I am happy to test anything that you might need, you'll just have to tolerate my ignorance along the way, lol. — Reply to this email directly, view it on GitHub <#690 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/ABTXEW4ZTT5TYB2F7YHMWO3VJ2PCBANCNFSM5VWDK7XA> . You are receiving this because you commented.Message ID: ***@***.***>

[RALEIGHthe3rd]

I have 2 mining rigs that run this exact same code. They both use ATMega328p boards as slaves. They use standard Arduino Nano core.

I know other people are using ATTIny85 boards, and it is recommended to use your ATTiny core.

I polled the community, I will let you know what (if anything), I hear back from them.

[RALEIGHthe3rd]

I thought I would post the code from the library and source files for the I2C slave from above. Not that I suspect it is anything to do with the ATTiny Core, just to get some eyes on it from people the know the tinys. Any help would be greatly appreciated.

/*
  This code was taken from the original github crypto-master zip file and slightly 
  modified to return a size_t type from the Sha1Class.write() call.

  https://github.com/Cathedrow/Cryptosuite

  The original code to the Cryptosuite library is contained within the 
  Cryptosuite-master sub-directory with the needed sha1.h/cpp files copied
  from there and modified as described above.
*/
#include <string.h>
//#include <avr/io.h>
//#include <avr/pgmspace.h>
#include "sha1.h"

#define SHA1_K0 0x5a827999
#define SHA1_K20 0x6ed9eba1
#define SHA1_K40 0x8f1bbcdc
#define SHA1_K60 0xca62c1d6

const uint8_t sha1InitState[] PROGMEM = {
  0x01,0x23,0x45,0x67, // H0
  0x89,0xab,0xcd,0xef, // H1
  0xfe,0xdc,0xba,0x98, // H2
  0x76,0x54,0x32,0x10, // H3
  0xf0,0xe1,0xd2,0xc3  // H4
};

void Sha1Class::init(void) {
  memcpy_P(state.b,sha1InitState,HASH_LENGTH);
  byteCount = 0;
  bufferOffset = 0;
}

uint32_t Sha1Class::rol32(uint32_t number, uint8_t bits) {
  return ((number << bits) | (number >> (32-bits)));
}

void Sha1Class::hashBlock() {
  uint8_t i;
  uint32_t a,b,c,d,e,t;

  a=state.w[0];
  b=state.w[1];
  c=state.w[2];
  d=state.w[3];
  e=state.w[4];
  for (i=0; i<80; i++) {
    if (i>=16) {
      t = buffer.w[(i+13)&15] ^ buffer.w[(i+8)&15] ^ buffer.w[(i+2)&15] ^ buffer.w[i&15];
      buffer.w[i&15] = rol32(t,1);
    }
    if (i<20) {
      t = (d ^ (b & (c ^ d))) + SHA1_K0;
    } else if (i<40) {
      t = (b ^ c ^ d) + SHA1_K20;
    } else if (i<60) {
      t = ((b & c) | (d & (b | c))) + SHA1_K40;
    } else {
      t = (b ^ c ^ d) + SHA1_K60;
    }
    t+=rol32(a,5) + e + buffer.w[i&15];
    e=d;
    d=c;
    c=rol32(b,30);
    b=a;
    a=t;
  }
  state.w[0] += a;
  state.w[1] += b;
  state.w[2] += c;
  state.w[3] += d;
  state.w[4] += e;
}

void Sha1Class::addUncounted(uint8_t data) {
  buffer.b[bufferOffset ^ 3] = data;
  bufferOffset++;
  if (bufferOffset == BLOCK_LENGTH) {
    hashBlock();
    bufferOffset = 0;
  }
}

size_t Sha1Class::write(uint8_t data) {
  ++byteCount;
  addUncounted(data);
  return 1;
}

void Sha1Class::pad() {
  // Implement SHA-1 padding (fips180-2 §5.1.1)

  // Pad with 0x80 followed by 0x00 until the end of the block
  addUncounted(0x80);
  while (bufferOffset != 56) addUncounted(0x00);

  // Append length in the last 8 bytes
  addUncounted(0); // We're only using 32 bit lengths
  addUncounted(0); // But SHA-1 supports 64 bit lengths
  addUncounted(0); // So zero pad the top bits
  addUncounted(byteCount >> 29); // Shifting to multiply by 8
  addUncounted(byteCount >> 21); // as SHA-1 supports bitstreams as well as
  addUncounted(byteCount >> 13); // byte.
  addUncounted(byteCount >> 5);
  addUncounted(byteCount << 3);
}


uint8_t* Sha1Class::result(void) {
  // Pad to complete the last block
  pad();
  
  // Swap byte order back
  for (int i=0; i<5; i++) {
    uint32_t a,b;
    a=state.w[i];
    b=a<<24;
    b|=(a<<8) & 0x00ff0000;
    b|=(a>>8) & 0x0000ff00;
    b|=a>>24;
    state.w[i]=b;
  }
  
  // Return pointer to hash (20 characters)
  return state.b;
}

#define HMAC_IPAD 0x36
#define HMAC_OPAD 0x5c

void Sha1Class::initHmac(const uint8_t* key, int keyLength) {
  uint8_t i;
  memset(keyBuffer,0,BLOCK_LENGTH);
  if (keyLength > BLOCK_LENGTH) {
    // Hash long keys
    init();
    for (;keyLength--;) write(*key++);
    memcpy(keyBuffer,result(),HASH_LENGTH);
  } else {
    // Block length keys are used as is
    memcpy(keyBuffer,key,keyLength);
  }
  // Start inner hash
  init();
  for (i=0; i<BLOCK_LENGTH; i++) {
    write(keyBuffer[i] ^ HMAC_IPAD);
  }
}

uint8_t* Sha1Class::resultHmac(void) {
  uint8_t i;
  // Complete inner hash
  memcpy(innerHash,result(),HASH_LENGTH);
  // Calculate outer hash
  init();
  for (i=0; i<BLOCK_LENGTH; i++) write(keyBuffer[i] ^ HMAC_OPAD);
  for (i=0; i<HASH_LENGTH; i++) write(innerHash[i]);
  return result();
}
Sha1Class Sha1;

/*
  This code was taken from the original github crypto-master zip file and slightly 
  modified to return a size_t type from the Sha1Class.write() call.

  https://github.com/Cathedrow/Cryptosuite

  The original code to the Cryptosuite library is contained within the 
  Cryptosuite-master sub-directory with the needed sha1.h/cpp files copied
  from there and modified as described above.
*/
#ifndef Sha1_h
#define Sha1_h

#include <inttypes.h>
#include "Print.h"

#define HASH_LENGTH 20
#define BLOCK_LENGTH 64

union _buffer {
  uint8_t b[BLOCK_LENGTH];
  uint32_t w[BLOCK_LENGTH/4];
};
union _state {
  uint8_t b[HASH_LENGTH];
  uint32_t w[HASH_LENGTH/4];
};

class Sha1Class : public Print
{
  public:
    void init(void);
    void initHmac(const uint8_t* secret, int secretLength);
    uint8_t* result(void);
    uint8_t* resultHmac(void);
    virtual size_t write(uint8_t);
    using Print::write;
  private:
    void pad();
    void addUncounted(uint8_t data);
    void hashBlock();
    uint32_t rol32(uint32_t number, uint8_t bits);
    _buffer buffer;
    uint8_t bufferOffset;
    _state state;
    uint32_t byteCount;
    uint8_t keyBuffer[BLOCK_LENGTH];
    uint8_t innerHash[HASH_LENGTH];
    
};
extern Sha1Class Sha1;

#endif

[SpenceKonde]

Sweet, so 2.0.0-dev solves it? Awesome. Next, test it after I commit the next round of changes to those files (which shouldn't change things for the 88 or 48, but should change them for everything else?

On another topic.... Hm. do you get a greater reward if you get the hashes faster?

Cause uh.

rol32 method takes worst case time every time,, the part after // Swap byte order back and probably pad() and addUncounted() are also bad. They could experience significant speedup if reimplemented in inline assembly.

If there;s only going to be one hash being worked on at a time, you should also try to eliminate the use of the SHA1 class. Classes tend fo flummox the optimizer. This is probably why you don't get much from LTO.

You might also want to try doing it with a more modern chip, like one of the ones supported by megaTinyCore. They're cheap like tinies, but they havefull hardware multipliers and better instruction timing. Use like a 824 or 1624 (since it sounds like you don't need more flash.... tune the chip's internal ocillator (see the reference in the github repo on tuning), and run it at the highest frequency you can without it giving incorrect hash results. They will almost all run beautifully at 32 MHz (0/1-series don't usually).....And they execute call 1 cycle faster, and execute push, and st/std (store/store with displacement, that is copying from working registers to ram) in 1 clock instead of two. (SBI/CBI) also went from 2 to 1 clock) That's probably your best bang-to-buck ratio for an 8-bit AVR as far as performance is concerned.

2-series has dual serial ports too. I'm imagining a string of 1624's tied together by their serial ports reporting to a master up top (which might be using I2C to communicate with a bigger master....). Commands get sent to the RX of the top one's first serial port, checked whether the command argument is 0, if not, decrement command argument and pass it on to the next one. Any messagess coming from below, or a failure of the next guy down to reply immediately with an acknolwdgement would be reported as an error). I'd avoid Serial like the plague for this (ir's ISRs are ungofly, even after I put tons of work into improving them) and implement my own rxc ISR that did nothing but copy the usart data of one port ro the txdata of the other, and since you'd run them all at the same baud rate, you'd know there was space in the buffer as long as you never disabled interrupts. Oh, and if the nxt one in chain didn't ack, you could use a pin controlling th gate of a fet to powercycle it. But why am I telling you things that will make you compete with me for scarce supplies of new chips? the parts you really want are backordered into next year.

Also, btw - disable millis (tools -> millis -> disable) if you don't use millis or micros in your code (regardless of what part) if performance matters. It doesn't help much but it helps a little.

[RALEIGHthe3rd]

No, I haven't got it completely working yet. 2.0.0 has the same result as originally posted. 30% failure rate when I get everything running. Seems like if the slave (Tiny88) takes <2.84 seconds for a job, it is accepted. Equal to or greater that 2.84 seconds, and the slave returns 0, 000 as the result and fails the job. It is like there is an unintentional timeout somewhere in the code. Oscillator or clock calculation that is wrong somewhere?

After asking around, sounds like the only ATTiny boards being used successfully is the Tiny85. Most people end up using esp32 or esp8266 boards, and don't venture into I2C at all. AVRs are in a different category for rewards, which is why I went with them on I2C.

Duino Coin is a little bit interesting, faster is not better. The higher the hash rate, the lower the rewards per hash. Also, the higher the difficulty, the lower the rewards, and each miner only earns 96% reward of the previous miner, It is designed to limit large mining rigs, and promote low cost, low energy devices. Also, the mining pools have a lot of restrictions, and if they see something beyond what they are expecting for results or rewards, they ban you pretty quickly. That being said, I am super interested to research some of you suggestions. At this point it sounds pretty far over my head, lol. The project is not for money, and probably never will be, just for fun. It is my first experience with Arduinos and microcontrollers in general.

I will see what happens if I remove millis(). I think the job elapsed time is reported to the mining pool, but not sure what happens if I don't send it.

I bought the Tiny88 because they were the cheapest per unit board I could find(by quite a bit), had I2C, and could be programmed without ISP. I got 20 of them and they were only $1.60 each. I was planning on testing to see how many I could use on one I2C bus before it started slowing down, and try ESP32 and ESP8266 as Masters for comparison. Eventually I want an array of 40-50 slaves total. Spending an extra few dollars on each board adds up really quick.