String to 'char*' problem. Syringe pump project

Projects Programming
1

Hi.
I'm trying to build a syringe pump for dispersing small amounts of liquids. I found this project, that is just what I need: http://www.mass-spec.ru/projects/diy/syringe_pump/eng/

The code is way above my level at the moment, so naturally I was hoping it would work as it is, seeing that other people have used it with success. That was, of course, not the case.

I get the following error messages, that all relate to the same issue. I have been trying to wrap my head around how to fix this for the past week, but I don't feel like I'm getting any closer.

/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino: In function 'void setup()':
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:123:42: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[1]  = {5, 0, 2, 0, TEXT, "Infuse"};
                                          ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:124:42: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[2]  = {7, 1, 3, 0, TEXT, "Refill"};
                                          ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:125:46: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[3]  = {9, 2, 4, 0, TEXT, "Cycle Mode"};
                                              ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:126:45: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[4]  = {10, 3, 0, 0, TEXT, "Settings"};
                                             ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:127:50: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[5]  = {15, 0, 6, 1, TEXT, "Target Volume"};
                                                  ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:128:48: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[6]  = {16, 5, 0, 1, TEXT, "Target Time"};
                                                ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:129:48: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[7]  = {17, 0, 8, 2, TEXT, "Full Refill"};
                                                ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:130:50: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[8]  = {18, 7, 0, 2, TEXT, "Target Volume"};
                                                  ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:131:77: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[9]  = {19, 0, CHANGEVALUE, 3, FLOWRATE, "infuse flow:", 1, 120000000};
                                                                             ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:132:43: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[10] = {20, 0, 11, 4, TEXT, "Units"};
                                           ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:133:46: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[11] = {23, 10, 12, 4, TEXT, "Syringe"};
                                              ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:134:47: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[12] = {25, 11, 13, 4, LIST, "Sound", 2};
                                               ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:135:48: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[13] = {27, 12, 14, 4, LIST, "EEPROM", 3};
                                                ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:136:56: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[14] = {FIRMWAREINFO, 13, 0, 4, TEXT, "Firmware"};
                                                        ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:137:68: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[15] = {29, 0, CHANGEVALUE, 5, VOLUME, "volume:", 4, 1000000};
                                                                    ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:138:62: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[16] = {30, 0, CHANGEVALUE, 6, TIME, "time:", 5, 60000};
                                                              ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:139:80: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[17] = {REFILLFULL, 0, CHANGEVALUE, 7, FLOWRATE, "flowrate:", 6, 2000000};
                                                                                ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:140:68: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[18] = {31, 0, CHANGEVALUE, 8, VOLUME, "volume:", 7, 1000000};
                                                                    ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:141:82: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[19] = {CYCLEMODE, 0, CHANGEVALUE, 9, FLOWRATE, "refill flow:", 8, 2000000};
                                                                                  ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:142:54: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[20] = {32, 0, 21, 10, LIST, "Volume Units", 9};
                                                      ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:143:54: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[21] = {34, 20, 22, 10, LIST, "Time Units", 10};
                                                      ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:144:57: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[22] = {37, 21, 0, 10, LIST, "Flowrate Units", 11};
                                                         ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:145:47: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[23] = {41, 0, 24, 11, TEXT, "Diameter"};
                                               ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:146:52: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[24] = {42, 23, 0, 11, TEXT, "Length/Volume"};
                                                    ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:147:53: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[25] = {SELECTFROMLIST, 0, 26, 12, TEXT, "on"};
                                                     ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:148:54: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[26] = {SELECTFROMLIST, 25, 0, 12, TEXT, "off"};
                                                      ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:149:53: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[27] = {SELECTFROMLIST, 0, 28, 13, TEXT, "on"};
                                                     ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:150:54: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[28] = {SELECTFROMLIST, 27, 0, 13, TEXT, "off"};
                                                      ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:151:84: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[29] = {INFUSEVOLUME, 0, CHANGEVALUE, 15, FLOWRATE, "flowrate:", 12, 2000000};
                                                                                    ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:152:82: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[30] = {INFUSETIME, 0, CHANGEVALUE, 16, FLOWRATE, "flowrate:", 13, 2000000};
                                                                                  ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:153:84: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[31] = {REFILLVOLUME, 0, CHANGEVALUE, 18, FLOWRATE, "flowrate:", 14, 2000000};
                                                                                    ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:154:53: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[32] = {SELECTFROMLIST, 0, 33, 20, TEXT, "mL"};
                                                     ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:155:53: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[33] = {SELECTFROMLIST, 32, 0, 20, TEXT, "uL"};
                                                     ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:156:52: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[34] = {SELECTFROMLIST, 0, 35, 21, TEXT, "s"};
                                                    ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:157:55: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[35] = {SELECTFROMLIST, 34, 36, 21, TEXT, "min"};
                                                       ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:158:52: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[36] = {SELECTFROMLIST, 35, 0, 21, TEXT, "h"};
                                                    ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:159:55: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[37] = {SELECTFROMLIST, 0, 38, 22, TEXT, "mL/s"};
                                                       ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:160:58: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[38] = {SELECTFROMLIST, 37, 39, 22, TEXT, "mL/min"};
                                                          ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:161:56: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[39] = {SELECTFROMLIST, 38, 40, 22, TEXT, "uL/s"};
                                                        ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:162:57: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[40] = {SELECTFROMLIST, 39, 0, 22, TEXT, "uL/min"};
                                                         ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:163:71: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[41] = {0, 0, CHANGEVALUE, 23, DIAMETER, "diameter:", 15, 11284};
                                                                       ^
/Users/Anders/Documents/Arduino/Syringe_pump1/Syringe_pump1.ino:164:83: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   items[42] = {0, 0, CHANGEVALUE, 24, LENGTHPERVOLUME, "length/volume:", 16, 10000};
                                                                                   ^
#include <LiquidCrystal.h>
#include <EEPROM.h>



/********************************************************************
          BASIC SETTINGS
********************************************************************/

// Stepper motor
#define NOFMICROSTEPS 16      // The number of microsteps per step
#define NOFSTEPSPER360 200    // The number of steps per revolution
#define MAXRPM 240            // Maximum RPM (rotations per minute)
#define INVERTDIRECTION true // If the carriage moves in the opposite direction, change to 'false'

// Leadscrew
#define MMPER360 2            // Leadscrew pitch, mm per revolution

// Arduino pins
#define STEP_PIN 2            // STEP pin (A4988)
#define DIRECTION_PIN 3       // DIR pin (A4988)
#define ENABLE_PIN 12         // EN pin (A4988)
#define ENDSTOP_PIN1 A1       // Endstop pin (forward movement)
#define ENDSTOP_PIN2 A2       // Endstop pin (backward movement)
#define BUZZER_PIN 11         // Buzzer pin
#define BUTTONS_PIN A0        // Button pin (lcd keypad shield)

/********************************************************************/



#define DEBOUNCEDELAY 50
#define LONGPRESSDELAY 450
#define AUTOCHANGINGDELAY 300

#define NITEMS 43

#define LINK2S 12
#define LINK2E 13
#define LINK2V 20
#define LINK2T 21
#define LINK2F 22
#define LINK2DIA 41
#define LINK2LPV 42

LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

struct MenuItem
{
  uint8_t button[4];
  uint8_t type;
  char *text;
  uint8_t address;
  uint32_t value;
};

enum listOfButtons {RIGHT, UP, DOWN, LEFT, SELECT, NA};
enum listOfButtonStates {RELEASE, SHORTPRESS, MEDIUMPRESS, LONGPRESS};
enum listOfPrograms {CHANGEVALUE = 200, SELECTFROMLIST, INFUSEVOLUME, INFUSETIME, REFILLVOLUME, REFILLFULL, CYCLEMODE, FIRMWAREINFO};
enum listOfItemTypes {TEXT, LIST, VOLUME, TIME, FLOWRATE, LENGTHPERVOLUME, DIAMETER};

const char firmwareInfo[] = "0.9a";
const uint16_t volumeDivider[2] = {1000, 1};
const uint16_t timeDivider[3] = {1, 60, 3600};
const uint16_t flowrateDivider[4] = {60000, 1000, 60, 1};
const float stepsPERmm = NOFSTEPSPER360 / MMPER360;

MenuItem items[NITEMS];
uint8_t lastButton = NA;
uint8_t buttonState = RELEASE;
uint32_t buttonPressTime = 0;
uint8_t currentItem = 1;
float coef;
uint8_t endStopPin;
volatile uint32_t ustepCounter;
uint32_t ustepCounterLimit;

uint32_t getValue(uint8_t itemNo);
void changeValue();
void setValue(uint8_t itemNo, uint8_t digits[8]);
void selectFromList();
void calculateActualValue(uint8_t itemNo);
void recalculateSyringe(uint8_t itemNo);
void printScreen();
void printUnits();
void printFirmwareInfo();
void printTimeAndVolume(uint16_t pumpingTime, uint32_t pumpingVolume);
void showScreensaver();
void readFromEEPROM(uint8_t itemNo);
void writeToEEPROM(uint8_t itemNo);
void getButtonState();
uint16_t valueDivider (uint8_t n);
uint8_t getElementNo(uint8_t linkToList);
void waitingForButton(uint8_t buttonCode, uint8_t itemNo);
void beep (uint16_t delayOn = 15, uint16_t delayOff = 100);
bool checkEndstop(int8_t pumpingDirection);
void infuseVolume();
void infuseTime();
void refillVolume();
void refillFull();
void pumpSingly(int8_t pumpingDirection, uint32_t flowrate, uint32_t volume);
void pumpContinuously();
uint8_t pump(uint32_t flowrate, uint32_t volume);



/********************************************************************
  setup
********************************************************************/
void setup()
{
  lcd.begin(16, 2);

  pinMode(STEP_PIN, OUTPUT);
  pinMode(DIRECTION_PIN, OUTPUT);
  pinMode(ENABLE_PIN, OUTPUT);
  pinMode(ENDSTOP_PIN1, INPUT_PULLUP);
  pinMode(ENDSTOP_PIN2, INPUT_PULLUP);
  pinMode(BUZZER_PIN, OUTPUT);

  digitalWrite(ENABLE_PIN, HIGH);

  items[1]  = {5, 0, 2, 0, TEXT, "Infuse"};
  items[2]  = {7, 1, 3, 0, TEXT, "Refill"};
  items[3]  = {9, 2, 4, 0, TEXT, "Cycle Mode"};
  items[4]  = {10, 3, 0, 0, TEXT, "Settings"};
  items[5]  = {15, 0, 6, 1, TEXT, "Target Volume"};
  items[6]  = {16, 5, 0, 1, TEXT, "Target Time"};
  items[7]  = {17, 0, 8, 2, TEXT, "Full Refill"};
  items[8]  = {18, 7, 0, 2, TEXT, "Target Volume"};
  items[9]  = {19, 0, CHANGEVALUE, 3, FLOWRATE, "infuse flow:", 1, 120000000};
  items[10] = {20, 0, 11, 4, TEXT, "Units"};
  items[11] = {23, 10, 12, 4, TEXT, "Syringe"};
  items[12] = {25, 11, 13, 4, LIST, "Sound", 2};
  items[13] = {27, 12, 14, 4, LIST, "EEPROM", 3};
  items[14] = {FIRMWAREINFO, 13, 0, 4, TEXT, "Firmware"};
  items[15] = {29, 0, CHANGEVALUE, 5, VOLUME, "volume:", 4, 1000000};
  items[16] = {30, 0, CHANGEVALUE, 6, TIME, "time:", 5, 60000};
  items[17] = {REFILLFULL, 0, CHANGEVALUE, 7, FLOWRATE, "flowrate:", 6, 2000000};
  items[18] = {31, 0, CHANGEVALUE, 8, VOLUME, "volume:", 7, 1000000};
  items[19] = {CYCLEMODE, 0, CHANGEVALUE, 9, FLOWRATE, "refill flow:", 8, 2000000};
  items[20] = {32, 0, 21, 10, LIST, "Volume Units", 9};
  items[21] = {34, 20, 22, 10, LIST, "Time Units", 10};
  items[22] = {37, 21, 0, 10, LIST, "Flowrate Units", 11};
  items[23] = {41, 0, 24, 11, TEXT, "Diameter"};
  items[24] = {42, 23, 0, 11, TEXT, "Length/Volume"};
  items[25] = {SELECTFROMLIST, 0, 26, 12, TEXT, "on"};
  items[26] = {SELECTFROMLIST, 25, 0, 12, TEXT, "off"};
  items[27] = {SELECTFROMLIST, 0, 28, 13, TEXT, "on"};
  items[28] = {SELECTFROMLIST, 27, 0, 13, TEXT, "off"};
  items[29] = {INFUSEVOLUME, 0, CHANGEVALUE, 15, FLOWRATE, "flowrate:", 12, 2000000};
  items[30] = {INFUSETIME, 0, CHANGEVALUE, 16, FLOWRATE, "flowrate:", 13, 2000000};
  items[31] = {REFILLVOLUME, 0, CHANGEVALUE, 18, FLOWRATE, "flowrate:", 14, 2000000};
  items[32] = {SELECTFROMLIST, 0, 33, 20, TEXT, "mL"};
  items[33] = {SELECTFROMLIST, 32, 0, 20, TEXT, "uL"};
  items[34] = {SELECTFROMLIST, 0, 35, 21, TEXT, "s"};
  items[35] = {SELECTFROMLIST, 34, 36, 21, TEXT, "min"};
  items[36] = {SELECTFROMLIST, 35, 0, 21, TEXT, "h"};
  items[37] = {SELECTFROMLIST, 0, 38, 22, TEXT, "mL/s"};
  items[38] = {SELECTFROMLIST, 37, 39, 22, TEXT, "mL/min"};
  items[39] = {SELECTFROMLIST, 38, 40, 22, TEXT, "uL/s"};
  items[40] = {SELECTFROMLIST, 39, 0, 22, TEXT, "uL/min"};
  items[41] = {0, 0, CHANGEVALUE, 23, DIAMETER, "diameter:", 15, 11284};
  items[42] = {0, 0, CHANGEVALUE, 24, LENGTHPERVOLUME, "length/volume:", 16, 10000};

  for (uint8_t i = 1; i < NITEMS; i++)
  {
    if (items[i].type != TEXT) readFromEEPROM(i);
  }

  recalculateSyringe(LINK2DIA);
  beep();
  showScreensaver();
}



/********************************************************************
  loop
********************************************************************/
void loop()
{
  uint8_t nextItem;
  getButtonState();
  if (buttonState == SHORTPRESS && lastButton != SELECT)
  {
    buttonState = MEDIUMPRESS;

    nextItem = items[currentItem].button[lastButton];
    if (nextItem != 0 && nextItem < 200)
    {
      currentItem = nextItem;
      printScreen();
    }
    else if (nextItem == CHANGEVALUE) changeValue();
    else if (nextItem == SELECTFROMLIST) selectFromList();
    else if (nextItem == INFUSEVOLUME) infuseVolume();
    else if (nextItem == INFUSETIME) infuseTime();
    else if (nextItem == REFILLVOLUME) refillVolume();
    else if (nextItem == REFILLFULL) refillFull();
    else if (nextItem == CYCLEMODE) pumpContinuously();
    else if (nextItem == FIRMWAREINFO) printFirmwareInfo();
  }
}



/********************************************************************
  getValue
********************************************************************/
uint32_t getValue(uint8_t itemNo)
{
  uint16_t divider = valueDivider(items[itemNo].type);
  uint8_t lastDigitIncrement = 0;
  if ( uint16_t(items[itemNo].value % divider) > divider / 2) lastDigitIncrement = 1;

  if (items[itemNo].value / divider > 99999999)
  {
    items[itemNo].value = divider * 99999999;
    return 99999999;
  }
  else return (items[itemNo].value / divider) + lastDigitIncrement;
}



/********************************************************************
  changeValue
********************************************************************/
void changeValue()
{
  uint8_t digits[8];
  uint32_t value = getValue(currentItem);
  for (int8_t i = 7; i >= 0; i--)
  {
    digits[i] = uint8_t(value % 10);
    value /= 10;
  }

  lcd.setCursor(0, 1);
  for (int8_t i = 0; i < 4; i++) lcd.print(digits[i]);

  lcd.setCursor(0, 1);
  lcd.cursor();
  int8_t i = 0;
  while (i >= 0 && i < 8)
  {
    getButtonState();
    if (buttonState == SHORTPRESS || buttonState == LONGPRESS)
    {
      if (lastButton == UP) digits[i] = (digits[i] + 1) % 10;
      else if (lastButton == DOWN) digits[i] = (digits[i] + 9) % 10;
      lcd.print(digits[i]);

      if (lastButton == RIGHT) i++;
      else if (lastButton == LEFT) i--;

      if (i == -1 && buttonState != SHORTPRESS) i++;
      if (i == 8 && buttonState != SHORTPRESS) i--;

      if (i < 5)lcd.setCursor(i, 1);
      else lcd.setCursor(i + 1, 1);

      if (buttonState == SHORTPRESS) buttonState = MEDIUMPRESS;
      else if (buttonState == LONGPRESS)
      {
        uint32_t nextMillis = millis() + AUTOCHANGINGDELAY;
        while (nextMillis > millis() && buttonState == LONGPRESS) getButtonState();
      }
    }
  }

  if (i == 8)
  {
    bool isSame = true;
    value = getValue(currentItem);
    for (int8_t j = 7; j >= 0 && isSame == true; j--)
    {
      if (digits[j] != uint8_t(value % 10)) isSame = false;
      value /= 10;
    }

    bool isZero = true;
    for (int8_t j = 7; j >= 0 && isZero == true; j--)
    {
      if (digits[j] != 0) isZero = false;
    }

    if (isSame == false && isZero == false)
    {
      setValue(currentItem, digits);
      beep();
    }
  }

  lcd.noCursor();
  lcd.setCursor(0, 1);
  printScreen();
}



/********************************************************************
  setValue
********************************************************************/
void setValue(uint8_t itemNo, uint8_t digits[8])
{
  uint32_t value = 0;
  for (int8_t i = 0; i < 8; i++) value = value * 10 + digits[i];

  uint16_t divider = valueDivider(items[itemNo].type);
  if (4294000000 / divider < value) items[itemNo].value = 4294000000;
  else items[itemNo].value = value * divider;

  if (itemNo == LINK2LPV || itemNo == LINK2DIA)
  {
    recalculateSyringe(itemNo);
    writeToEEPROM(LINK2LPV);
    writeToEEPROM(LINK2DIA);
  }
  else writeToEEPROM(itemNo);
}



/********************************************************************
  selectFromList
********************************************************************/
void selectFromList()
{
  uint8_t parentItem = items[currentItem].button[LEFT];
  items[parentItem].button[RIGHT] = currentItem;
  writeToEEPROM(parentItem);
  beep();
  currentItem = parentItem;
  printScreen();
}



/********************************************************************
  calculateActualValue
********************************************************************/
void calculateActualValue(uint8_t itemNo)
{
  if (items[itemNo].type == FLOWRATE)
  {
    float maxFlowrate = 1e9 * MAXRPM * MMPER360 / (float)items[LINK2LPV].value;
    if ((float)(items[itemNo].value) > maxFlowrate) items[itemNo].value = (uint32_t)maxFlowrate;

    float ustepsPERmin = coef * NOFMICROSTEPS * (float)items[itemNo].value;
    if (ustepsPERmin < 14.4) ustepsPERmin = 14.4;
    float multiplier;
    if (ustepsPERmin >= 229) multiplier = 15000000;
    else multiplier = 937500;
    float tempFloat = multiplier / ustepsPERmin;
    uint16_t countsPERustepActual = (uint16_t)(tempFloat + 0.5);
    tempFloat = multiplier / (float)countsPERustepActual;
    tempFloat /= (float)(coef * NOFMICROSTEPS);
    items[itemNo].value = (uint32_t)tempFloat;
  }

  else if (items[itemNo].type == VOLUME)
  {
    uint32_t nSteps = (uint32_t)(coef * (float)items[itemNo].value + 0.5);
    float tempFloat = (float)nSteps / coef;
    items[itemNo].value = (uint32_t)tempFloat;
  }

  else if (items[itemNo].type == TIME)
  {
    if (items[itemNo].value > 59994000) items[itemNo].value = 59994000;
    items[itemNo].value -= (items[itemNo].value % 1000);
  }
}



/********************************************************************
  recalculateSyringe
********************************************************************/
void recalculateSyringe(uint8_t itemNo)
{
  if (itemNo == LINK2LPV)
  {
    float temp = 1128379 / sqrt((float)items[LINK2LPV].value);
    items[LINK2DIA].value = uint32_t(temp + 0.5);
  }
  else if (itemNo == LINK2DIA)
  {
    float temp = 1128379 / (float)items[LINK2DIA].value;
    temp *= temp;
    items[LINK2LPV].value = uint32_t(temp + 0.5);
  }

  coef = ((float)items[LINK2LPV].value * stepsPERmm) * 1e-9;
}



/********************************************************************
  printScreen
********************************************************************/
void printScreen()
{
  lcd.clear();
  lcd.setCursor(0, 0);

  if (items[currentItem].type == TEXT || items[currentItem].type == LIST)
  {
    lcd.print(F("> "));
    lcd.print(items[currentItem].text);

    if (items[currentItem].button[DOWN] != 0 && items[currentItem].button[DOWN] < 200)
    {
      lcd.setCursor(0, 1);
      lcd.print(F("  "));
      lcd.print(items[items[currentItem].button[DOWN]].text);
    }
  }

  else
  {
    calculateActualValue(currentItem);
    uint32_t value = getValue(currentItem);
    char outputLine[10] = "    0.000";
    for (int8_t i = 8; i >= 0 && value > 0; i--)
    {
      if (i != 5)
      {
        outputLine[i] = char((value % 10) + '0');
        value /= 10;
      }
    }

    lcd.print(items[currentItem].text);
    lcd.setCursor(0, 1);
    lcd.print(outputLine);
    printUnits();
  }
}



/********************************************************************
  printUnits
********************************************************************/
void printUnits()
{
  lcd.print(F(" "));
  if (items[currentItem].type == VOLUME) lcd.print(items[items[LINK2V].button[RIGHT]].text);
  else if (items[currentItem].type == TIME) lcd.print(items[items[LINK2T].button[RIGHT]].text);
  else if (items[currentItem].type == FLOWRATE) lcd.print(items[items[LINK2F].button[RIGHT]].text);
  else if (items[currentItem].type == LENGTHPERVOLUME)
  {
    lcd.print(F("mm/"));
    lcd.print(items[items[LINK2V].button[RIGHT]].text);
  }
  else if (items[currentItem].type == DIAMETER) lcd.print(F("mm"));
}



/********************************************************************
  printFirmwareInfo
********************************************************************/
void printFirmwareInfo()
{
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(F("version:"));
  lcd.setCursor(0, 1);
  lcd.print(F("  "));
  lcd.print(firmwareInfo);

  waitingForButton(LEFT, currentItem);
}



/********************************************************************
  printTimeAndVolume
********************************************************************/
void printTimeAndVolume(uint16_t pumpingTime, uint32_t pumpingVolume)
{
  char outputLine[17] = "  0:00    0000xL";
  outputLine[14] = items[items[LINK2V].button[RIGHT]].text[0];

  uint8_t pointLocation;
  if (pumpingVolume < 100000)pointLocation = 3;
  else if (pumpingVolume < 1000000)
  {
    pointLocation = 4;
    pumpingVolume /= 10;
  }
  else
  {
    pointLocation = 6;
    pumpingVolume /= 100;
  }
  if (pointLocation < 6)outputLine[pointLocation + 8] = '.';
  uint16_t timeDivider;
  for (int8_t i = 5; i >= 0; i--)
  {
    if (pumpingTime > 0 && i != 3)
    {
      if (i == 4) timeDivider = 6;
      else timeDivider = 10;
      outputLine[i] = uint8_t(pumpingTime % timeDivider) + '0';
      pumpingTime /= timeDivider;
    }

    if (pumpingVolume > 0 && i != pointLocation)
    {
      outputLine[i + 8] = uint8_t(pumpingVolume % 10) + '0';
      pumpingVolume /= 10;
    }
  }

  lcd.setCursor(0, 1);
  lcd.print(outputLine);
}



/********************************************************************
  showScreensaver
********************************************************************/
void showScreensaver()
{
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(F("   OpenSP 0.9   "));
  lcd.setCursor(0, 1);
  lcd.print(F("www.mass-spec.ru"));
  currentItem = 1;
  waitingForButton(NA, currentItem);
}



/********************************************************************
  getButtonState
********************************************************************/
void getButtonState()
{
  uint8_t button;

  uint8_t x = analogRead(BUTTONS_PIN) / 4;
  if (x < 13) button = RIGHT;
  else if (x < 46) button = UP;
  else if (x < 84) button = DOWN;
  else if (x < 131) button = LEFT;
  else if (x < 207) button = SELECT;
  else button = NA;

  if (button == NA)
  {
    lastButton = NA;
    buttonState = RELEASE;
  }
  else if (button != lastButton)
  {
    lastButton = button;
    buttonState = RELEASE;
    buttonPressTime = millis();
  }
  else if (millis() - buttonPressTime > LONGPRESSDELAY) buttonState = LONGPRESS;
  else if (millis() - buttonPressTime > DEBOUNCEDELAY && buttonState == RELEASE) buttonState = SHORTPRESS;
}



/********************************************************************
  valueDivider
********************************************************************/
uint16_t valueDivider (uint8_t itemType)
{
  if (itemType == VOLUME) return volumeDivider[getElementNo(LINK2V)];
  else if (itemType == TIME) return timeDivider[getElementNo(LINK2T)];
  else if (itemType == FLOWRATE) return flowrateDivider[getElementNo(LINK2F)];
  else if (itemType == LENGTHPERVOLUME) return 1000 / volumeDivider[getElementNo(LINK2V)];
  else if (itemType == DIAMETER) return 1;
}



/********************************************************************
  getElementNo
********************************************************************/
uint8_t getElementNo(uint8_t linkToList)
{
  uint8_t uppermostItem = items[linkToList].button[RIGHT];
  uint8_t elementNo = 0;
  while (items[uppermostItem].button[UP] != 0)
  {
    uppermostItem = items[uppermostItem].button[UP];
    elementNo++;
  }
  return elementNo;
}



/********************************************************************
  waitingForButton
********************************************************************/
void waitingForButton(uint8_t button, uint8_t itemNo)
{
  if (button == NA) while (buttonState != SHORTPRESS) getButtonState();
  else while (buttonState != SHORTPRESS || lastButton != button) getButtonState();
  buttonState = MEDIUMPRESS;
  currentItem = itemNo;
  printScreen();
}



/********************************************************************
  beep
********************************************************************/
void beep (uint16_t delayOn, uint16_t delayOff)
{
  uint8_t daughterItem = items[LINK2S].button[RIGHT];
  if (items[daughterItem].text == "on")
  {
    digitalWrite(BUZZER_PIN, HIGH);
    delay(delayOn);
    digitalWrite(BUZZER_PIN, LOW);
    delay(delayOff);
  }
}



/********************************************************************
  checkEndstop
********************************************************************/
bool checkEndstop(int8_t pumpingDirection)
{
  bool canMove = true;
  if (digitalRead(ENDSTOP_PIN1) == LOW && pumpingDirection > 0) canMove = false;
  else if (digitalRead(ENDSTOP_PIN2) == LOW && pumpingDirection < 0) canMove = false;

  if (canMove == false)
  {
    lcd.clear();
    lcd.setCursor(0, 0);
    if (pumpingDirection > 0) lcd.print(F("SYRINGE IS EMPTY"));
    else if (pumpingDirection < 0) lcd.print(F("SYRINGE IS FULL"));
    beep(300);
    waitingForButton(LEFT, 1);
    return false;
  }
  else return true;
}



/********************************************************************
  readFromEEPROM
********************************************************************/
void readFromEEPROM(uint8_t itemNo)
{
  if (items[itemNo].type == LIST)
  {
    uint8_t temp;
    EEPROM.get(4 * items[itemNo].address, temp);
    if (temp != 0 && temp + 1 != 0)
    {
      if (items[temp].button[LEFT] == itemNo) items[itemNo].button[RIGHT] = temp;
    }
  }
  else
  {
    uint32_t temp;
    EEPROM.get(4 * items[itemNo].address, temp);
    if (temp != 0 && temp + 1 != 0) items[itemNo].value = temp;
  }
}



/********************************************************************
  writeToEEPROM
********************************************************************/
void writeToEEPROM(uint8_t itemNo)
{
  uint8_t daughterItem = items[LINK2E].button[RIGHT];
  if (items[daughterItem].text == "on" || itemNo == LINK2E)
  {
    if (items[itemNo].type == LIST) EEPROM.put(4 * items[itemNo].address, items[itemNo].button[RIGHT]);
    else EEPROM.put(4 * items[itemNo].address, items[itemNo].value);
  }
}



/********************************************************************
  infuseVolume
********************************************************************/
void infuseVolume()
{
  int8_t pumpingDirection = 1;
  uint32_t flowrate = items[currentItem].value;
  uint32_t volume = items[items[currentItem].button[LEFT]].value;

  pumpSingly(pumpingDirection, flowrate, volume);
}



/********************************************************************
  infuseTime
********************************************************************/
void infuseTime()
{
  int8_t pumpingDirection = 1;
  uint32_t pumpTime = items[items[currentItem].button[LEFT]].value;
  uint32_t flowrate = items[currentItem].value;
  float tempFloat = (float)flowrate * (float)pumpTime;
  tempFloat /= 60000;
  uint32_t volume;
  if (tempFloat > 4294000000) volume = 4294000000;
  else volume = (uint32_t)tempFloat;

  pumpSingly(pumpingDirection, flowrate, volume);
}



/********************************************************************
  refillVolume
********************************************************************/
void refillVolume()
{
  int8_t pumpingDirection = -1;
  uint32_t flowrate = items[currentItem].value;
  uint32_t volume = items[items[currentItem].button[LEFT]].value;

  pumpSingly(pumpingDirection, flowrate, volume);
}



/********************************************************************
  refillFull
********************************************************************/
void refillFull()
{
  int8_t pumpingDirection = -1;
  uint32_t flowrate = items[currentItem].value;
  uint32_t volume = 4294000000;

  pumpSingly(pumpingDirection, flowrate, volume);
}



/********************************************************************
  pumpSingly
********************************************************************/
void pumpSingly(int8_t pumpingDirection, uint32_t flowrate, uint32_t volume)
{
  if (checkEndstop(pumpingDirection) == true)
  {
    pump(pumpingDirection, flowrate, volume);
    beep(300);
    waitingForButton(LEFT, 1);
  }
}



/********************************************************************
  pumpContinuously
********************************************************************/
void pumpContinuously()
{
  int8_t pumpingDirection[2] = {1, -1};
  uint32_t flowrate[2] = {items[items[currentItem].button[LEFT]].value, items[currentItem].value};
  uint32_t volume = 4294000000;
  uint8_t i = 0;

  while (pump(pumpingDirection[i], flowrate[i], volume) != 2)
  {
    i = 1 - i;
    beep();
    delay(1000);
  }

  beep(300);
  waitingForButton(LEFT, 1);
}



/********************************************************************
  pump
********************************************************************/
uint8_t pump(int8_t pumpingDirection, uint32_t flowrate, uint32_t volume)
{
  float tempFloat;

  ustepCounterLimit = (uint32_t)(coef * volume + 0.5);
  ustepCounterLimit *= NOFMICROSTEPS;

  float ustepsPERmin = coef * NOFMICROSTEPS * (float)flowrate;
  if (ustepsPERmin < 14.4) ustepsPERmin = 14.4;
  float multiplier;
  if (ustepsPERmin >= 229) multiplier = 15000000;
  else multiplier = 937500;
  tempFloat = multiplier / ustepsPERmin;
  uint16_t countsPERustepActual = (uint16_t)(tempFloat + 0.5);
  float ustepsPERsActual = multiplier / (float)countsPERustepActual;
  ustepsPERsActual /= 60;

  lcd.clear();
  lcd.setCursor(0, 0);
  if (pumpingDirection > 0)
  {
    endStopPin = ENDSTOP_PIN1;
    if (INVERTDIRECTION == true) digitalWrite(DIRECTION_PIN, LOW);
    else digitalWrite(DIRECTION_PIN, HIGH);
    lcd.print(F(" >> INFUSING >> "));
  }
  else
  {
    endStopPin = ENDSTOP_PIN2;
    if (INVERTDIRECTION == true) digitalWrite(DIRECTION_PIN, HIGH);
    else digitalWrite(DIRECTION_PIN, LOW);
    lcd.print(F(" << REFILLING <<"));
  }
  lcd.setCursor(0, 1);
  printTimeAndVolume(0, 0);

  TCNT1 = 0;
  TCCR1A = 0;
  TCCR1B |= (1 << WGM12);
  if (ustepsPERmin >= 229)
  {
    TCCR1B &= ~( 1 << CS12);
    TCCR1B |= (1 << CS11);
    TCCR1B |= (1 << CS10);
  }
  else
  {
    TCCR1B |= (1 << CS12);
    TCCR1B &= ~( 1 << CS11);
    TCCR1B |= (1 << CS10);
  }

  digitalWrite(ENABLE_PIN, LOW);
  digitalWrite(STEP_PIN, LOW);

  ustepCounter = 1;
  uint32_t ustepCounterActual;
  float coef2 = ((float)items[LINK2LPV].value * stepsPERmm * 1e-9) * (float)valueDivider(VOLUME) * NOFMICROSTEPS * 10;
  bool isManualStop = false;
  uint32_t pumpingVolume;
  uint16_t pumpingTime = 1;
  uint32_t nextMillis = millis() + 1000;
  OCR1A = (countsPERustepActual - 1);
  TIMSK1 |= (1 << OCIE1A);
  while ( (TIMSK1 & (1 << OCIE1A)) )
  {
    getButtonState();
    if (buttonState == SHORTPRESS && lastButton == LEFT)
    {
      buttonState = MEDIUMPRESS;
      lcd.setCursor(0, 0);
      lcd.print(F("  STOP PUMPING? "));
      lcd.setCursor(0, 1);
      lcd.print(F("(YES)       (NO)"));
      while ( (TIMSK1 & (1 << OCIE1A)) )
      {
        getButtonState();
        if (buttonState == SHORTPRESS)
        {
          buttonState = MEDIUMPRESS;
          if (lastButton == LEFT)
          {
            TIMSK1 &= ~( 1 << OCIE1A);
            isManualStop = true;
          }
          else if (lastButton == RIGHT)
          {
            lcd.setCursor(0, 0);
            if (pumpingDirection > 0) lcd.print(F(" >> INFUSING >> "));
            else lcd.print(F(" << REFILLING <<"));
            break;
          }
        }
      }
    }

    if (nextMillis <= millis())
    {
      cli();
      ustepCounterActual = ustepCounter;
      sei();

      pumpingVolume = (uint32_t)(((float)ustepCounterActual / coef2) + 0.5);
      printTimeAndVolume(pumpingTime, pumpingVolume);
      pumpingTime++;
      nextMillis += 1000;
    }
  }

  digitalWrite(ENABLE_PIN, HIGH);

  lcd.setCursor(0, 1);
  pumpingVolume = (uint32_t)(((float)ustepCounter / coef2) + 0.5);
  printTimeAndVolume(pumpingTime, pumpingVolume);


  lcd.setCursor(0, 0);
  if (isManualStop)
  {
    lcd.print(F("  MANUAL STOP   "));
    return 2;
  }
  if (ustepCounterLimit == ustepCounter - 1)
  {
    lcd.print(F("    FINISHED    "));
    return 0;
  }
  else
  {
    lcd.print(F("UNEXPECTED STOP "));
    return 1;
  }
}



/********************************************************************
  ISR(TIMER1_COMPA_vect)
********************************************************************/
ISR(TIMER1_COMPA_vect)
{
  digitalWrite(STEP_PIN, HIGH);
  if (ustepCounter == ustepCounterLimit) TIMSK1 &= ~( 1 << OCIE1A);
  if ( digitalRead(endStopPin) == LOW) TIMSK1 &= ~( 1 << OCIE1A);
  delayMicroseconds(10);
  digitalWrite(STEP_PIN, LOW);
  ustepCounter++;
}
2

it's only warnings, it should compile fine but if you want to get rid of the warnings, change the Menu structure definition to

struct MenuItem
{
  uint8_t button[4];
  uint8_t type;
  const char *text;  // <== add const here 
  uint8_t address;
  uint32_t value;
};

you might also want to edit this function and add a return in case all the if are wrong, that will get rid of the other warning (code is not great, this could be allocated at compile time in the array definition, also they don't make use of entry 0 apparently)

uint16_t valueDivider (uint8_t itemType)
{
  if (itemType == VOLUME) return volumeDivider[getElementNo(LINK2V)];
  else if (itemType == TIME) return timeDivider[getElementNo(LINK2T)];
  else if (itemType == FLOWRATE) return flowrateDivider[getElementNo(LINK2F)];
  else if (itemType == LENGTHPERVOLUME) return 1000 / volumeDivider[getElementNo(LINK2V)];
  else if (itemType == DIAMETER) return 1;
  return 1; // <=== ADD THIS LINE
}
3

What you are getting are warning messages, not error messages

For instance,

C:\Users\Bob2\AppData\Local\Temp\arduino_modified_sketch_746116\sketch_apr22a.ino:584:1: warning: control reaches end of non-void function [-Wreturn-type]
 }

you have this function that promises to return a value of type uint16_t, ie an unsigned int

uint16_t valueDivider (uint8_t itemType)
{
  if (itemType == VOLUME) return volumeDivider[getElementNo(LINK2V)];
  else if (itemType == TIME) return timeDivider[getElementNo(LINK2T)];
  else if (itemType == FLOWRATE) return flowrateDivider[getElementNo(LINK2F)];
  else if (itemType == LENGTHPERVOLUME) return 1000 / volumeDivider[getElementNo(LINK2V)];
  else if (itemType == DIAMETER) return 1;
}

But no value is actually returned, hence the warning in case you meant to return something

and this one

C:\Users\Bob2\AppData\Local\Temp\arduino_modified_sketch_746116\sketch_apr22a.ino:690:35: warning: comparison with string literal results in unspecified behavior [-Waddress]
   if (items[daughterItem].text == "on" || itemNo == LINK2E)

which is warning that you can't compare text like that and be sure that it works

The things that you are being warned about may not be a problem and they don't stop the code compiling but the program may not behave as you want it to

4

Sorry. I perceived them as errors, since the code doesn't work. As it is, nothing displays on the LCD, so it is not very useful.

5

there could be tons of reasons for this

assuming you installed the right LiquidCrystal library , did you wire the LCD right so that LiquidCrystal lcd(8, 9, 4, 5, 6, 7) would do the right thing ?

test with a very simple code that all the elements you wired are working

and of course this (as found by @UKHeliBob) is a bug

rewrite that as

if (!strcmp(items[daughterItem].text, "on") || itemNo == LINK2E)

6

Yes. I have tested that, and it works fine with other codes, so I think the hardware should be ok.

7

do you have the same lcd keypad shield?

try this code just to see if anything gets displayed

#include <LiquidCrystal.h>
#define BUTTONS_PIN A0        // Button pin (lcd keypad shield)
#define DEBOUNCEDELAY 50
#define LONGPRESSDELAY 450
#define AUTOCHANGINGDELAY 300

enum t_listOfButtons : byte {RIGHT, UP, DOWN, LEFT, SELECT, NA};
const char* buttonsTxt[] = {"RIGHT", "UP", "DOWN", "LEFT", "SELECT", "NA"};
enum t_listOfButtonStates : byte {RELEASE, SHORTPRESS, MEDIUMPRESS, LONGPRESS};
const char* buttonStatesTxt[] = {"RELEASE", "SHORTPRESS", "MEDIUMPRESS", "LONGPRESS"};

t_listOfButtons lastButton = NA;
t_listOfButtonStates buttonState = RELEASE;
uint32_t buttonPressTime = 0;

LiquidCrystal lcd(8, 9, 4, 5, 6, 7);


void getButtonState()
{
  t_listOfButtons button;

  uint8_t x = analogRead(BUTTONS_PIN) / 4;
  if (x < 13) button = RIGHT;
  else if (x < 46) button = UP;
  else if (x < 84) button = DOWN;
  else if (x < 131) button = LEFT;
  else if (x < 207) button = SELECT;
  else button = NA;

  if (button == NA) {
    lastButton = NA;
    buttonState = RELEASE;
  } else if (button != lastButton) {
    lastButton = button;
    buttonState = RELEASE;
    buttonPressTime = millis();
  }
  else if (millis() - buttonPressTime > LONGPRESSDELAY) buttonState = LONGPRESS;
  else if (millis() - buttonPressTime > DEBOUNCEDELAY && buttonState == RELEASE) buttonState = SHORTPRESS;
}

void setup()
{
  lcd.begin(16, 2);
  lcd.setCursor(0, 0);
  lcd.print(F("Press any key"));
}

void loop()
{
  t_listOfButtonStates oldState = RELEASE;
  t_listOfButtons oldButton = NA;

  getButtonState();
  if ((oldButton != lastButton) || (buttonState != oldState)) {
    oldState = buttonState;
    oldButton = lastButton;
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print(buttonsTxt[lastButton]);
    lcd.setCursor(0, 1);
    lcd.print(buttonStatesTxt[buttonState]);
  }
}

(totally untested, just extracted and slightly modified their code)

8

Probably not, as the original project is from 2017.

Nothing

9

OK try this code:

#include <LiquidCrystal.h>
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

void setup() {
  lcd.begin(16, 2);
  lcd.setCursor(0, 0);
  lcd.print(F("Hello Asche"));
}

void loop() {}

anything on the LCD?

(can you provide links to your hardware)

10

Nope.

I'm using this:https://www.adafruit.com/product/772

11

this is an I2C driven module. you need to change the library (use Adafruit_RGBLCDShield if that's the product you bought) and the way it's instantiated

what code did you use to test it post assembly?

12

I used the various examples provided on the adafruit website.

This works.



/
#include <Adafruit_RGBLCDShield.h>
Adafruit_RGBLCDShield lcd = Adafruit_RGBLCDShield();

void setup() {
  lcd.begin(16, 2);
  lcd.setCursor(0, 0);
  lcd.print(F("Hello Asche"));
}

void loop() {}
13

That put me on the right track.

At least now I have something on the display. Buttons don't do anything though, but I guess that is a similar problem.


#include <EEPROM.h>
#include <Adafruit_RGBLCDShield.h>




/********************************************************************
          BASIC SETTINGS
********************************************************************/

// Stepper motor
#define NOFMICROSTEPS 16      // The number of microsteps per step
#define NOFSTEPSPER360 200    // The number of steps per revolution
#define MAXRPM 240            // Maximum RPM (rotations per minute)
#define INVERTDIRECTION true // If the carriage moves in the opposite direction, change to 'false'

// Leadscrew
#define MMPER360 2            // Leadscrew pitch, mm per revolution

// Arduino pins
#define STEP_PIN 2            // STEP pin (A4988)
#define DIRECTION_PIN 3       // DIR pin (A4988)
#define ENABLE_PIN 12         // EN pin (A4988)
#define ENDSTOP_PIN1 A1       // Endstop pin (forward movement)
#define ENDSTOP_PIN2 A2       // Endstop pin (backward movement)
#define BUZZER_PIN 11         // Buzzer pin
#define BUTTONS_PIN A0        // Button pin (lcd keypad shield)

/********************************************************************/



#define DEBOUNCEDELAY 50
#define LONGPRESSDELAY 450
#define AUTOCHANGINGDELAY 300

#define NITEMS 43

#define LINK2S 12
#define LINK2E 13
#define LINK2V 20
#define LINK2T 21
#define LINK2F 22
#define LINK2DIA 41
#define LINK2LPV 42


Adafruit_RGBLCDShield lcd = Adafruit_RGBLCDShield();
struct MenuItem
{
  uint8_t button[4];
  uint8_t type;
  const char *text;
  uint8_t address;
  uint32_t value;
};

enum listOfButtons {RIGHT, UP, DOWN, LEFT, SELECT, NA};
enum listOfButtonStates {RELEASE, SHORTPRESS, MEDIUMPRESS, LONGPRESS};
enum listOfPrograms {CHANGEVALUE = 200, SELECTFROMLIST, INFUSEVOLUME, INFUSETIME, REFILLVOLUME, REFILLFULL, CYCLEMODE, FIRMWAREINFO};
enum listOfItemTypes {TEXT, LIST, VOLUME, TIME, FLOWRATE, LENGTHPERVOLUME, DIAMETER};

const char firmwareInfo[] = "0.9a";
const uint16_t volumeDivider[2] = {1000, 1};
const uint16_t timeDivider[3] = {1, 60, 3600};
const uint16_t flowrateDivider[4] = {60000, 1000, 60, 1};
const float stepsPERmm = NOFSTEPSPER360 / MMPER360;

MenuItem items[NITEMS];
uint8_t lastButton = NA;
uint8_t buttonState = RELEASE;
uint32_t buttonPressTime = 0;
uint8_t currentItem = 1;
float coef;
uint8_t endStopPin;
volatile uint32_t ustepCounter;
uint32_t ustepCounterLimit;

uint32_t getValue(uint8_t itemNo);
void changeValue();
void setValue(uint8_t itemNo, uint8_t digits[8]);
void selectFromList();
void calculateActualValue(uint8_t itemNo);
void recalculateSyringe(uint8_t itemNo);
void printScreen();
void printUnits();
void printFirmwareInfo();
void printTimeAndVolume(uint16_t pumpingTime, uint32_t pumpingVolume);
void showScreensaver();
void readFromEEPROM(uint8_t itemNo);
void writeToEEPROM(uint8_t itemNo);
void getButtonState();
uint16_t valueDivider (uint8_t n);
uint8_t getElementNo(uint8_t linkToList);
void waitingForButton(uint8_t buttonCode, uint8_t itemNo);
void beep (uint16_t delayOn = 15, uint16_t delayOff = 100);
bool checkEndstop(int8_t pumpingDirection);
void infuseVolume();
void infuseTime();
void refillVolume();
void refillFull();
void pumpSingly(int8_t pumpingDirection, uint32_t flowrate, uint32_t volume);
void pumpContinuously();
uint8_t pump(uint32_t flowrate, uint32_t volume);



/********************************************************************
  setup
********************************************************************/
void setup()
{
  lcd.begin(16, 2);

  pinMode(STEP_PIN, OUTPUT);
  pinMode(DIRECTION_PIN, OUTPUT);
  pinMode(ENABLE_PIN, OUTPUT);
  pinMode(ENDSTOP_PIN1, INPUT_PULLUP);
  pinMode(ENDSTOP_PIN2, INPUT_PULLUP);
  pinMode(BUZZER_PIN, OUTPUT);

  digitalWrite(ENABLE_PIN, HIGH);

  items[1]  = {5, 0, 2, 0, TEXT, "Infuse"};
  items[2]  = {7, 1, 3, 0, TEXT, "Refill"};
  items[3]  = {9, 2, 4, 0, TEXT, "Cycle Mode"};
  items[4]  = {10, 3, 0, 0, TEXT, "Settings"};
  items[5]  = {15, 0, 6, 1, TEXT, "Target Volume"};
  items[6]  = {16, 5, 0, 1, TEXT, "Target Time"};
  items[7]  = {17, 0, 8, 2, TEXT, "Full Refill"};
  items[8]  = {18, 7, 0, 2, TEXT, "Target Volume"};
  items[9]  = {19, 0, CHANGEVALUE, 3, FLOWRATE, "infuse flow:", 1, 120000000};
  items[10] = {20, 0, 11, 4, TEXT, "Units"};
  items[11] = {23, 10, 12, 4, TEXT, "Syringe"};
  items[12] = {25, 11, 13, 4, LIST, "Sound", 2};
  items[13] = {27, 12, 14, 4, LIST, "EEPROM", 3};
  items[14] = {FIRMWAREINFO, 13, 0, 4, TEXT, "Firmware"};
  items[15] = {29, 0, CHANGEVALUE, 5, VOLUME, "volume:", 4, 1000000};
  items[16] = {30, 0, CHANGEVALUE, 6, TIME, "time:", 5, 60000};
  items[17] = {REFILLFULL, 0, CHANGEVALUE, 7, FLOWRATE, "flowrate:", 6, 2000000};
  items[18] = {31, 0, CHANGEVALUE, 8, VOLUME, "volume:", 7, 1000000};
  items[19] = {CYCLEMODE, 0, CHANGEVALUE, 9, FLOWRATE, "refill flow:", 8, 2000000};
  items[20] = {32, 0, 21, 10, LIST, "Volume Units", 9};
  items[21] = {34, 20, 22, 10, LIST, "Time Units", 10};
  items[22] = {37, 21, 0, 10, LIST, "Flowrate Units", 11};
  items[23] = {41, 0, 24, 11, TEXT, "Diameter"};
  items[24] = {42, 23, 0, 11, TEXT, "Length/Volume"};
  items[25] = {SELECTFROMLIST, 0, 26, 12, TEXT, "on"};
  items[26] = {SELECTFROMLIST, 25, 0, 12, TEXT, "off"};
  items[27] = {SELECTFROMLIST, 0, 28, 13, TEXT, "on"};
  items[28] = {SELECTFROMLIST, 27, 0, 13, TEXT, "off"};
  items[29] = {INFUSEVOLUME, 0, CHANGEVALUE, 15, FLOWRATE, "flowrate:", 12, 2000000};
  items[30] = {INFUSETIME, 0, CHANGEVALUE, 16, FLOWRATE, "flowrate:", 13, 2000000};
  items[31] = {REFILLVOLUME, 0, CHANGEVALUE, 18, FLOWRATE, "flowrate:", 14, 2000000};
  items[32] = {SELECTFROMLIST, 0, 33, 20, TEXT, "mL"};
  items[33] = {SELECTFROMLIST, 32, 0, 20, TEXT, "uL"};
  items[34] = {SELECTFROMLIST, 0, 35, 21, TEXT, "s"};
  items[35] = {SELECTFROMLIST, 34, 36, 21, TEXT, "min"};
  items[36] = {SELECTFROMLIST, 35, 0, 21, TEXT, "h"};
  items[37] = {SELECTFROMLIST, 0, 38, 22, TEXT, "mL/s"};
  items[38] = {SELECTFROMLIST, 37, 39, 22, TEXT, "mL/min"};
  items[39] = {SELECTFROMLIST, 38, 40, 22, TEXT, "uL/s"};
  items[40] = {SELECTFROMLIST, 39, 0, 22, TEXT, "uL/min"};
  items[41] = {0, 0, CHANGEVALUE, 23, DIAMETER, "diameter:", 15, 11284};
  items[42] = {0, 0, CHANGEVALUE, 24, LENGTHPERVOLUME, "length/volume:", 16, 10000};

  for (uint8_t i = 1; i < NITEMS; i++)
  {
    if (items[i].type != TEXT) readFromEEPROM(i);
  }

  recalculateSyringe(LINK2DIA);
  beep();
  showScreensaver();
}



/********************************************************************
  loop
********************************************************************/
void loop()
{
  uint8_t nextItem;
  getButtonState();
  if (buttonState == SHORTPRESS && lastButton != SELECT)
  {
    buttonState = MEDIUMPRESS;

    nextItem = items[currentItem].button[lastButton];
    if (nextItem != 0 && nextItem < 200)
    {
      currentItem = nextItem;
      printScreen();
    }
    else if (nextItem == CHANGEVALUE) changeValue();
    else if (nextItem == SELECTFROMLIST) selectFromList();
    else if (nextItem == INFUSEVOLUME) infuseVolume();
    else if (nextItem == INFUSETIME) infuseTime();
    else if (nextItem == REFILLVOLUME) refillVolume();
    else if (nextItem == REFILLFULL) refillFull();
    else if (nextItem == CYCLEMODE) pumpContinuously();
    else if (nextItem == FIRMWAREINFO) printFirmwareInfo();
  }
}



/********************************************************************
  getValue
********************************************************************/
uint32_t getValue(uint8_t itemNo)
{
  uint16_t divider = valueDivider(items[itemNo].type);
  uint8_t lastDigitIncrement = 0;
  if ( uint16_t(items[itemNo].value % divider) > divider / 2) lastDigitIncrement = 1;

  if (items[itemNo].value / divider > 99999999)
  {
    items[itemNo].value = divider * 99999999;
    return 99999999;
  }
  else return (items[itemNo].value / divider) + lastDigitIncrement;
}



/********************************************************************
  changeValue
********************************************************************/
void changeValue()
{
  uint8_t digits[8];
  uint32_t value = getValue(currentItem);
  for (int8_t i = 7; i >= 0; i--)
  {
    digits[i] = uint8_t(value % 10);
    value /= 10;
  }

  lcd.setCursor(0, 1);
  for (int8_t i = 0; i < 4; i++) lcd.print(digits[i]);

  lcd.setCursor(0, 1);
  lcd.cursor();
  int8_t i = 0;
  while (i >= 0 && i < 8)
  {
    getButtonState();
    if (buttonState == SHORTPRESS || buttonState == LONGPRESS)
    {
      if (lastButton == UP) digits[i] = (digits[i] + 1) % 10;
      else if (lastButton == DOWN) digits[i] = (digits[i] + 9) % 10;
      lcd.print(digits[i]);

      if (lastButton == RIGHT) i++;
      else if (lastButton == LEFT) i--;

      if (i == -1 && buttonState != SHORTPRESS) i++;
      if (i == 8 && buttonState != SHORTPRESS) i--;

      if (i < 5)lcd.setCursor(i, 1);
      else lcd.setCursor(i + 1, 1);

      if (buttonState == SHORTPRESS) buttonState = MEDIUMPRESS;
      else if (buttonState == LONGPRESS)
      {
        uint32_t nextMillis = millis() + AUTOCHANGINGDELAY;
        while (nextMillis > millis() && buttonState == LONGPRESS) getButtonState();
      }
    }
  }

  if (i == 8)
  {
    bool isSame = true;
    value = getValue(currentItem);
    for (int8_t j = 7; j >= 0 && isSame == true; j--)
    {
      if (digits[j] != uint8_t(value % 10)) isSame = false;
      value /= 10;
    }

    bool isZero = true;
    for (int8_t j = 7; j >= 0 && isZero == true; j--)
    {
      if (digits[j] != 0) isZero = false;
    }

    if (isSame == false && isZero == false)
    {
      setValue(currentItem, digits);
      beep();
    }
  }

  lcd.noCursor();
  lcd.setCursor(0, 1);
  printScreen();
}



/********************************************************************
  setValue
********************************************************************/
void setValue(uint8_t itemNo, uint8_t digits[8])
{
  uint32_t value = 0;
  for (int8_t i = 0; i < 8; i++) value = value * 10 + digits[i];

  uint16_t divider = valueDivider(items[itemNo].type);
  if (4294000000 / divider < value) items[itemNo].value = 4294000000;
  else items[itemNo].value = value * divider;

  if (itemNo == LINK2LPV || itemNo == LINK2DIA)
  {
    recalculateSyringe(itemNo);
    writeToEEPROM(LINK2LPV);
    writeToEEPROM(LINK2DIA);
  }
  else writeToEEPROM(itemNo);
}



/********************************************************************
  selectFromList
********************************************************************/
void selectFromList()
{
  uint8_t parentItem = items[currentItem].button[LEFT];
  items[parentItem].button[RIGHT] = currentItem;
  writeToEEPROM(parentItem);
  beep();
  currentItem = parentItem;
  printScreen();
}



/********************************************************************
  calculateActualValue
********************************************************************/
void calculateActualValue(uint8_t itemNo)
{
  if (items[itemNo].type == FLOWRATE)
  {
    float maxFlowrate = 1e9 * MAXRPM * MMPER360 / (float)items[LINK2LPV].value;
    if ((float)(items[itemNo].value) > maxFlowrate) items[itemNo].value = (uint32_t)maxFlowrate;

    float ustepsPERmin = coef * NOFMICROSTEPS * (float)items[itemNo].value;
    if (ustepsPERmin < 14.4) ustepsPERmin = 14.4;
    float multiplier;
    if (ustepsPERmin >= 229) multiplier = 15000000;
    else multiplier = 937500;
    float tempFloat = multiplier / ustepsPERmin;
    uint16_t countsPERustepActual = (uint16_t)(tempFloat + 0.5);
    tempFloat = multiplier / (float)countsPERustepActual;
    tempFloat /= (float)(coef * NOFMICROSTEPS);
    items[itemNo].value = (uint32_t)tempFloat;
  }

  else if (items[itemNo].type == VOLUME)
  {
    uint32_t nSteps = (uint32_t)(coef * (float)items[itemNo].value + 0.5);
    float tempFloat = (float)nSteps / coef;
    items[itemNo].value = (uint32_t)tempFloat;
  }

  else if (items[itemNo].type == TIME)
  {
    if (items[itemNo].value > 59994000) items[itemNo].value = 59994000;
    items[itemNo].value -= (items[itemNo].value % 1000);
  }
}



/********************************************************************
  recalculateSyringe
********************************************************************/
void recalculateSyringe(uint8_t itemNo)
{
  if (itemNo == LINK2LPV)
  {
    float temp = 1128379 / sqrt((float)items[LINK2LPV].value);
    items[LINK2DIA].value = uint32_t(temp + 0.5);
  }
  else if (itemNo == LINK2DIA)
  {
    float temp = 1128379 / (float)items[LINK2DIA].value;
    temp *= temp;
    items[LINK2LPV].value = uint32_t(temp + 0.5);
  }

  coef = ((float)items[LINK2LPV].value * stepsPERmm) * 1e-9;
}



/********************************************************************
  printScreen
********************************************************************/
void printScreen()
{
  lcd.clear();
  lcd.setCursor(0, 0);

  if (items[currentItem].type == TEXT || items[currentItem].type == LIST)
  {
    lcd.print(F("> "));
    lcd.print(items[currentItem].text);

    if (items[currentItem].button[DOWN] != 0 && items[currentItem].button[DOWN] < 200)
    {
      lcd.setCursor(0, 1);
      lcd.print(F("  "));
      lcd.print(items[items[currentItem].button[DOWN]].text);
    }
  }

  else
  {
    calculateActualValue(currentItem);
    uint32_t value = getValue(currentItem);
    char outputLine[10] = "    0.000";
    for (int8_t i = 8; i >= 0 && value > 0; i--)
    {
      if (i != 5)
      {
        outputLine[i] = char((value % 10) + '0');
        value /= 10;
      }
    }

    lcd.print(items[currentItem].text);
    lcd.setCursor(0, 1);
    lcd.print(outputLine);
    printUnits();
  }
}



/********************************************************************
  printUnits
********************************************************************/
void printUnits()
{
  lcd.print(F(" "));
  if (items[currentItem].type == VOLUME) lcd.print(items[items[LINK2V].button[RIGHT]].text);
  else if (items[currentItem].type == TIME) lcd.print(items[items[LINK2T].button[RIGHT]].text);
  else if (items[currentItem].type == FLOWRATE) lcd.print(items[items[LINK2F].button[RIGHT]].text);
  else if (items[currentItem].type == LENGTHPERVOLUME)
  {
    lcd.print(F("mm/"));
    lcd.print(items[items[LINK2V].button[RIGHT]].text);
  }
  else if (items[currentItem].type == DIAMETER) lcd.print(F("mm"));
}



/********************************************************************
  printFirmwareInfo
********************************************************************/
void printFirmwareInfo()
{
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(F("version:"));
  lcd.setCursor(0, 1);
  lcd.print(F("  "));
  lcd.print(firmwareInfo);

  waitingForButton(LEFT, currentItem);
}



/********************************************************************
  printTimeAndVolume
********************************************************************/
void printTimeAndVolume(uint16_t pumpingTime, uint32_t pumpingVolume)
{
  char outputLine[17] = "  0:00    0000xL";
  outputLine[14] = items[items[LINK2V].button[RIGHT]].text[0];

  uint8_t pointLocation;
  if (pumpingVolume < 100000)pointLocation = 3;
  else if (pumpingVolume < 1000000)
  {
    pointLocation = 4;
    pumpingVolume /= 10;
  }
  else
  {
    pointLocation = 6;
    pumpingVolume /= 100;
  }
  if (pointLocation < 6)outputLine[pointLocation + 8] = '.';
  uint16_t timeDivider;
  for (int8_t i = 5; i >= 0; i--)
  {
    if (pumpingTime > 0 && i != 3)
    {
      if (i == 4) timeDivider = 6;
      else timeDivider = 10;
      outputLine[i] = uint8_t(pumpingTime % timeDivider) + '0';
      pumpingTime /= timeDivider;
    }

    if (pumpingVolume > 0 && i != pointLocation)
    {
      outputLine[i + 8] = uint8_t(pumpingVolume % 10) + '0';
      pumpingVolume /= 10;
    }
  }

  lcd.setCursor(0, 1);
  lcd.print(outputLine);
}



/********************************************************************
  showScreensaver
********************************************************************/
void showScreensaver()
{
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(F("   OpenSP 0.9   "));
  lcd.setCursor(0, 1);
  lcd.print(F("www.mass-spec.ru"));
  currentItem = 1;
  waitingForButton(NA, currentItem);
}



/********************************************************************
  getButtonState
********************************************************************/
void getButtonState()
{
  uint8_t button;

  uint8_t x = analogRead(BUTTONS_PIN) / 4;
  if (x < 13) button = RIGHT;
  else if (x < 46) button = UP;
  else if (x < 84) button = DOWN;
  else if (x < 131) button = LEFT;
  else if (x < 207) button = SELECT;
  else button = NA;

  if (button == NA)
  {
    lastButton = NA;
    buttonState = RELEASE;
  }
  else if (button != lastButton)
  {
    lastButton = button;
    buttonState = RELEASE;
    buttonPressTime = millis();
  }
  else if (millis() - buttonPressTime > LONGPRESSDELAY) buttonState = LONGPRESS;
  else if (millis() - buttonPressTime > DEBOUNCEDELAY && buttonState == RELEASE) buttonState = SHORTPRESS;
}



/********************************************************************
  valueDivider
********************************************************************/
uint16_t valueDivider (uint8_t itemType)
{
  if (itemType == VOLUME) return volumeDivider[getElementNo(LINK2V)];
  else if (itemType == TIME) return timeDivider[getElementNo(LINK2T)];
  else if (itemType == FLOWRATE) return flowrateDivider[getElementNo(LINK2F)];
  else if (itemType == LENGTHPERVOLUME) return 1000 / volumeDivider[getElementNo(LINK2V)];
  else if (itemType == DIAMETER) return 1;
  return 1;
}



/********************************************************************
  getElementNo
********************************************************************/
uint8_t getElementNo(uint8_t linkToList)
{
  uint8_t uppermostItem = items[linkToList].button[RIGHT];
  uint8_t elementNo = 0;
  while (items[uppermostItem].button[UP] != 0)
  {
    uppermostItem = items[uppermostItem].button[UP];
    elementNo++;
  }
  return elementNo;
}



/********************************************************************
  waitingForButton
********************************************************************/
void waitingForButton(uint8_t button, uint8_t itemNo)
{
  if (button == NA) while (buttonState != SHORTPRESS) getButtonState();
  else while (buttonState != SHORTPRESS || lastButton != button) getButtonState();
  buttonState = MEDIUMPRESS;
  currentItem = itemNo;
  printScreen();
}



/********************************************************************
  beep
********************************************************************/
void beep (uint16_t delayOn, uint16_t delayOff)
{
  uint8_t daughterItem = items[LINK2S].button[RIGHT];
  if (items[daughterItem].text == "on")
  {
    digitalWrite(BUZZER_PIN, HIGH);
    delay(delayOn);
    digitalWrite(BUZZER_PIN, LOW);
    delay(delayOff);
  }
}



/********************************************************************
  checkEndstop
********************************************************************/
bool checkEndstop(int8_t pumpingDirection)
{
  bool canMove = true;
  if (digitalRead(ENDSTOP_PIN1) == LOW && pumpingDirection > 0) canMove = false;
  else if (digitalRead(ENDSTOP_PIN2) == LOW && pumpingDirection < 0) canMove = false;

  if (canMove == false)
  {
    lcd.clear();
    lcd.setCursor(0, 0);
    if (pumpingDirection > 0) lcd.print(F("SYRINGE IS EMPTY"));
    else if (pumpingDirection < 0) lcd.print(F("SYRINGE IS FULL"));
    beep(300);
    waitingForButton(LEFT, 1);
    return false;
  }
  else return true;
}



/********************************************************************
  readFromEEPROM
********************************************************************/
void readFromEEPROM(uint8_t itemNo)
{
  if (items[itemNo].type == LIST)
  {
    uint8_t temp;
    EEPROM.get(4 * items[itemNo].address, temp);
    if (temp != 0 && temp + 1 != 0)
    {
      if (items[temp].button[LEFT] == itemNo) items[itemNo].button[RIGHT] = temp;
    }
  }
  else
  {
    uint32_t temp;
    EEPROM.get(4 * items[itemNo].address, temp);
    if (temp != 0 && temp + 1 != 0) items[itemNo].value = temp;
  }
}



/********************************************************************
  writeToEEPROM
********************************************************************/
void writeToEEPROM(uint8_t itemNo)
{
  uint8_t daughterItem = items[LINK2E].button[RIGHT];
  if (!strcmp(items[daughterItem].text, "on") || itemNo == LINK2E)
  {
    if (items[itemNo].type == LIST) EEPROM.put(4 * items[itemNo].address, items[itemNo].button[RIGHT]);
    else EEPROM.put(4 * items[itemNo].address, items[itemNo].value);
  }
}



/********************************************************************
  infuseVolume
********************************************************************/
void infuseVolume()
{
  int8_t pumpingDirection = 1;
  uint32_t flowrate = items[currentItem].value;
  uint32_t volume = items[items[currentItem].button[LEFT]].value;

  pumpSingly(pumpingDirection, flowrate, volume);
}



/********************************************************************
  infuseTime
********************************************************************/
void infuseTime()
{
  int8_t pumpingDirection = 1;
  uint32_t pumpTime = items[items[currentItem].button[LEFT]].value;
  uint32_t flowrate = items[currentItem].value;
  float tempFloat = (float)flowrate * (float)pumpTime;
  tempFloat /= 60000;
  uint32_t volume;
  if (tempFloat > 4294000000) volume = 4294000000;
  else volume = (uint32_t)tempFloat;

  pumpSingly(pumpingDirection, flowrate, volume);
}



/********************************************************************
  refillVolume
********************************************************************/
void refillVolume()
{
  int8_t pumpingDirection = -1;
  uint32_t flowrate = items[currentItem].value;
  uint32_t volume = items[items[currentItem].button[LEFT]].value;

  pumpSingly(pumpingDirection, flowrate, volume);
}



/********************************************************************
  refillFull
********************************************************************/
void refillFull()
{
  int8_t pumpingDirection = -1;
  uint32_t flowrate = items[currentItem].value;
  uint32_t volume = 4294000000;

  pumpSingly(pumpingDirection, flowrate, volume);
}



/********************************************************************
  pumpSingly
********************************************************************/
void pumpSingly(int8_t pumpingDirection, uint32_t flowrate, uint32_t volume)
{
  if (checkEndstop(pumpingDirection) == true)
  {
    pump(pumpingDirection, flowrate, volume);
    beep(300);
    waitingForButton(LEFT, 1);
  }
}



/********************************************************************
  pumpContinuously
********************************************************************/
void pumpContinuously()
{
  int8_t pumpingDirection[2] = {1, -1};
  uint32_t flowrate[2] = {items[items[currentItem].button[LEFT]].value, items[currentItem].value};
  uint32_t volume = 4294000000;
  uint8_t i = 0;

  while (pump(pumpingDirection[i], flowrate[i], volume) != 2)
  {
    i = 1 - i;
    beep();
    delay(1000);
  }

  beep(300);
  waitingForButton(LEFT, 1);
}



/********************************************************************
  pump
********************************************************************/
uint8_t pump(int8_t pumpingDirection, uint32_t flowrate, uint32_t volume)
{
  float tempFloat;

  ustepCounterLimit = (uint32_t)(coef * volume + 0.5);
  ustepCounterLimit *= NOFMICROSTEPS;

  float ustepsPERmin = coef * NOFMICROSTEPS * (float)flowrate;
  if (ustepsPERmin < 14.4) ustepsPERmin = 14.4;
  float multiplier;
  if (ustepsPERmin >= 229) multiplier = 15000000;
  else multiplier = 937500;
  tempFloat = multiplier / ustepsPERmin;
  uint16_t countsPERustepActual = (uint16_t)(tempFloat + 0.5);
  float ustepsPERsActual = multiplier / (float)countsPERustepActual;
  ustepsPERsActual /= 60;

  lcd.clear();
  lcd.setCursor(0, 0);
  if (pumpingDirection > 0)
  {
    endStopPin = ENDSTOP_PIN1;
    if (INVERTDIRECTION == true) digitalWrite(DIRECTION_PIN, LOW);
    else digitalWrite(DIRECTION_PIN, HIGH);
    lcd.print(F(" >> INFUSING >> "));
  }
  else
  {
    endStopPin = ENDSTOP_PIN2;
    if (INVERTDIRECTION == true) digitalWrite(DIRECTION_PIN, HIGH);
    else digitalWrite(DIRECTION_PIN, LOW);
    lcd.print(F(" << REFILLING <<"));
  }
  lcd.setCursor(0, 1);
  printTimeAndVolume(0, 0);

  TCNT1 = 0;
  TCCR1A = 0;
  TCCR1B |= (1 << WGM12);
  if (ustepsPERmin >= 229)
  {
    TCCR1B &= ~( 1 << CS12);
    TCCR1B |= (1 << CS11);
    TCCR1B |= (1 << CS10);
  }
  else
  {
    TCCR1B |= (1 << CS12);
    TCCR1B &= ~( 1 << CS11);
    TCCR1B |= (1 << CS10);
  }

  digitalWrite(ENABLE_PIN, LOW);
  digitalWrite(STEP_PIN, LOW);

  ustepCounter = 1;
  uint32_t ustepCounterActual;
  float coef2 = ((float)items[LINK2LPV].value * stepsPERmm * 1e-9) * (float)valueDivider(VOLUME) * NOFMICROSTEPS * 10;
  bool isManualStop = false;
  uint32_t pumpingVolume;
  uint16_t pumpingTime = 1;
  uint32_t nextMillis = millis() + 1000;
  OCR1A = (countsPERustepActual - 1);
  TIMSK1 |= (1 << OCIE1A);
  while ( (TIMSK1 & (1 << OCIE1A)) )
  {
    getButtonState();
    if (buttonState == SHORTPRESS && lastButton == LEFT)
    {
      buttonState = MEDIUMPRESS;
      lcd.setCursor(0, 0);
      lcd.print(F("  STOP PUMPING? "));
      lcd.setCursor(0, 1);
      lcd.print(F("(YES)       (NO)"));
      while ( (TIMSK1 & (1 << OCIE1A)) )
      {
        getButtonState();
        if (buttonState == SHORTPRESS)
        {
          buttonState = MEDIUMPRESS;
          if (lastButton == LEFT)
          {
            TIMSK1 &= ~( 1 << OCIE1A);
            isManualStop = true;
          }
          else if (lastButton == RIGHT)
          {
            lcd.setCursor(0, 0);
            if (pumpingDirection > 0) lcd.print(F(" >> INFUSING >> "));
            else lcd.print(F(" << REFILLING <<"));
            break;
          }
        }
      }
    }

    if (nextMillis <= millis())
    {
      cli();
      ustepCounterActual = ustepCounter;
      sei();

      pumpingVolume = (uint32_t)(((float)ustepCounterActual / coef2) + 0.5);
      printTimeAndVolume(pumpingTime, pumpingVolume);
      pumpingTime++;
      nextMillis += 1000;
    }
  }

  digitalWrite(ENABLE_PIN, HIGH);

  lcd.setCursor(0, 1);
  pumpingVolume = (uint32_t)(((float)ustepCounter / coef2) + 0.5);
  printTimeAndVolume(pumpingTime, pumpingVolume);


  lcd.setCursor(0, 0);
  if (isManualStop)
  {
    lcd.print(F("  MANUAL STOP   "));
    return 2;
  }
  if (ustepCounterLimit == ustepCounter - 1)
  {
    lcd.print(F("    FINISHED    "));
    return 0;
  }
  else
  {
    lcd.print(F("UNEXPECTED STOP "));
    return 1;
  }
}



/********************************************************************
  ISR(TIMER1_COMPA_vect)
********************************************************************/
ISR(TIMER1_COMPA_vect)
{
  digitalWrite(STEP_PIN, HIGH);
  if (ustepCounter == ustepCounterLimit) TIMSK1 &= ~( 1 << OCIE1A);
  if ( digitalRead(endStopPin) == LOW) TIMSK1 &= ~( 1 << OCIE1A);
  delayMicroseconds(10);
  digitalWrite(STEP_PIN, LOW);
  ustepCounter++;
}
14

check the values for your resistors, in the getButtonState() function they use 13, 46, 84, 131 and 207 to differentiate button press.. (after dividing the input by 4)

15

As there aren't any resistors connected to the buttons here, I guess there must be a different way of telling them apart?

16

There should be - on the back of the circuit board. Check the assembly instructions for the Adafruit kit.

There is also a readButtons function in the library that you could try once you verify that the kit was properly constructed.

17

connect your shield to your Arduino and the Arduino to the PC and run this code

#define BUTTONS_PIN A0

void setup() {
  Serial.begin(115200);
}

void loop() {
  static int oldValue = -1;
  int newValue = analogRead(BUTTONS_PIN) / 4;
  if (newValue != oldValue) {
    oldValue = newValue;
    Serial.println(newValue);
  }
}

open the Serial monitor at 115200 bauds
press the buttons one by one and note the values you see (they might fluctuate a bit)
sort them in ascending order and find clear ranges and then modify the value assigned to the button variable and the threshold to match what you saw

if (x < 13) button = RIGHT;
  else if (x < 46) button = UP;
  else if (x < 84) button = DOWN;
  else if (x < 131) button = LEFT;
  else if (x < 207) button = SELECT;
  else button = NA;
18

Hmm.
None of the buttons give me anything at all. I know they work, as I tested with the example sketch in the library.

19

So try taking the code from the example and splice it into yours. Or better, make a small program that just reads the buttons.

20

maybe they are not connected to A0