Arduino.ru

не видно.

Зачем тут картинка? Не проще текст ошибки скопировать?

1. Исходники постим здесь (причём по правилам форума). И постим не с сайта, а прямо копипастом из своей IDE. Кому надо за Вашими исходниками лезть хрен знает куда, чтобы потом узнать, что "у Вас-то они такие же, только Вы поменяли номера пинов, ну и так - по мелочи"?

2. Текст сообщения об ошибке копипастим и тоже постим здесь (Вы хоть сами на этой картинке что-то видите?)

Ну, вот, как-то так.

Виноват, исправляюсь.

Исходник

#include <Wire.h>
#include <Time.h>
#include <LiquidCrystal_I2C.h>
#include <AlarmController.h>
#include <AlarmSettings.h>
#include <Bounce.h>
#include <Alarm.h>

const uint8_t snoozePin = 2;    //Purple 
const uint8_t leftPin = 3;      //Green
const uint8_t rightPin = 4;     //Brown
const uint8_t upPin = 5;        //Blue
const uint8_t downPin = 6;      //Orange
const uint8_t okPin = 8;        //Yellow
const uint8_t cancelPin = 8;    //Grey
const uint8_t ledPin = 9;       //White

const uint8_t buzzerPin = 13;

const uint8_t bounceDelay = 8;

double fadeValue = 0.0;
unsigned long timeStart = 0;
unsigned long timeHigh = 0;
unsigned long timeOn = 0;
unsigned long timeOnPrev = 0;
unsigned long buzzerStart = 0;
//                      x        x        x        x        x      x        x      x        x      x      x        x      x      x        x      x      x      x        x      x      x      x        x      x      x      x      x        x      x      x      x      x
const int buzzerP[] = {150,2000,150,2000,150,2000,150,2000,150,80,150,2000,150,80,150,2000,150,80,150,80,150,2000,150,80,150,80,150,2000,150,80,150,80,150,80,150,2000,150,80,150,80,150,80,150,2000,150,80,150,80,150,80,150,80,150,2000,150,80,150,80,150,80,150,80,150,1000};
const int buzzerPL = 64;
const uint8_t buzzerL = 54;
int buzzerPI = 0;

AlarmSettings set;
LiquidCrystal_I2C lcd(0x27,16,2); 

AlarmController ac(&set,&lcd,ledPin);

Bounce btnLeft = Bounce(leftPin,bounceDelay);
Bounce btnRight = Bounce(rightPin,bounceDelay);
Bounce btnUp = Bounce(upPin,bounceDelay);
Bounce btnDown = Bounce(downPin,bounceDelay);
Bounce btnOK = Bounce(okPin,bounceDelay);
Bounce btnCancel = Bounce(cancelPin,bounceDelay);
Bounce btnSnooze = Bounce(snoozePin,bounceDelay);

void setup()  { 
  pinMode(ledPin, OUTPUT);
  pinMode(snoozePin, INPUT);
  pinMode(leftPin, INPUT);
  pinMode(rightPin, INPUT);
  pinMode(upPin, INPUT);
  pinMode(downPin, INPUT);
  pinMode(okPin, INPUT);
  pinMode(cancelPin, INPUT);
  pinMode(buzzerPin, OUTPUT);
  timeStart = millis();
  timeOn = millis();
  timeOnPrev = timeOn;
  lcd.init();  
  lcd.setBacklight(1);
  lcd.home();
  
  lcd.print(F("setup   "));

  uint8_t ledOff[8] = 	{0b00000,
      	                 0b00000,
      	                 0b00000,
      	                 0b00000,
      	                 0b00100,
      	                 0b01110,
      	                 0b01110,
      	                 0b01110 };
  uint8_t ledOn[8] = {0b00100,
                      0b10101,
	              0b10101,
	              0b00000,
	              0b00100,
	              0b01110,
	              0b01110,
	              0b01110 };

  uint8_t checkbox1[8] = {0b00000,
                          0b11111,
	                  0b10001,
	                  0b10001,
	                  0b10001,
	                  0b10001,
	                  0b11111,
	                  0b00000 };

  uint8_t checkbox2[8] = {0b00000,
                          0b11111,
	                  0b10001,
	                  0b10101,
	                  0b10101,
	                  0b10001,
	                  0b11111,
	                  0b00000 };

  lcd.createChar(0b00000, ledOff);
  lcd.createChar(0b00001, ledOn);
  
  lcd.createChar(0b00010, checkbox1);
  lcd.createChar(0b00011, checkbox2);

  digitalWrite(buzzerPin, LOW);
  analogWrite(ledPin, 0);

  ac.setMakeLight(analogWrite);
} 

void loop()  { 
  //update time
  timeOn = millis();
  if(timeOn<timeOnPrev) { //overflow!!
    set.getTime()->addMillis((4294967295ul - timeOnPrev) + timeOn);
  }
  else{
    set.getTime()->addMillis(timeOn - timeOnPrev);
  }
  timeOnPrev = timeOn;
  
  //update AlarmState
  ac.checkAlarmState();
  
  //make noise?
  if(ac.mustMakeNoise()) {
    if(buzzerPI % 2 == 0) {
      digitalWrite(buzzerPin, HIGH);
    }
    else {
      digitalWrite(buzzerPin, LOW);
    }
    if(abs(millis() - buzzerStart) > buzzerP[buzzerPI]) {
      buzzerPI++;
      if(buzzerPI == buzzerPL)
        buzzerPI = buzzerL;
      buzzerStart = millis();
    } 
  }
  else {
    buzzerPI = 0;
    digitalWrite(buzzerPin, LOW);
  }
  
  //update LCD
  ac.printLCD();

  //check snooze-button
  btnSnooze.update();
  if(btnSnooze.risingEdge()) {
    ac.doSnooze();
    if(ac.getAlarmState() == 0) {
      timeStart = millis();
      btnSnooze.update();
      ac.printLCD();
      fadeValue = 0.0;
      analogWrite(ledPin,round(fadeValue));
      while(btnSnooze.read() == HIGH) {
        if(abs(millis() - timeStart) > 600) {
          //fadeValue += 15;
          fadeValue += (fadeValue / 600) + 1;
          if(fadeValue > 255) {
            fadeValue = 255.0;
          }
          analogWrite(ledPin,round(fadeValue));
          delay(10);
        }
        btnSnooze.update();
      }
    }
  }

  //Check other buttons
  btnLeft.update();
  btnRight.update();
  btnUp.update();
  btnDown.update();
  btnOK.update();
  btnCancel.update();

  if(btnOK.risingEdge()) {
    ac.doOK();
  }
  else if(btnCancel.risingEdge()) {
    ac.doCancel(); 
  }
  else if(btnLeft.risingEdge()) {
    ac.doLeft();
  }
  else if(btnLeft.fallingEdge()) {
    ac.endLeft();
  }
  else if(btnRight.risingEdge()) {
    ac.doRight();
  }
  else if(btnRight.fallingEdge()) {
    ac.endRight(); 
  }
  else if(btnUp.risingEdge()) {
    ac.doUp();
    btnUp.update();
    timeStart = millis();
    ac.printLCD();
    while(btnUp.read() == HIGH) {
      if(abs(millis() - timeStart) > 800) {
        ac.doUp();
        ac.printLCD();
        delay(140);
      }
      btnUp.update();
    }
  }
  else if(btnDown.risingEdge()) {
    ac.doDown();
    btnUp.update();
    timeStart = millis();
    ac.printLCD();
    while(btnDown.read() == HIGH) {
      if(abs(millis() - timeStart) > 800) {
        ac.doDown();
        ac.printLCD();
        delay(140);
      }
      btnDown.update();
    }
  }
  
}

Ошибка:

Судя по всему либо файл AlarmSettings.h битый, либо в нем содержатся неразрешенные ссылки.

Это библиотека AlarmSettings на которую он ругается, возможно проблема в getTime
#include "AlarmSettings.h"

char* _tomorrow = "Tomorrow";

AlarmSettings::AlarmSettings() {
  _wakeUpDur = 30;
  _wakeUpLum = 255;
  _snoozeDur = 5;
  _backlightDur = 5;
  _fadeOutDur = 30;
  _fadeOutActive = false;
  _time = new Time(0,13,37,00);
  _dayAlarm = new Alarm();
  _weekAlarm = new WeekAlarm();
  _alarmCfgNo = 7;
}

void AlarmSettings::setWakeUpDur(uint8_t wakeUpDur) {
  _wakeUpDur = wakeUpDur;
}

uint8_t AlarmSettings::getWakeUpDur() {
  return _wakeUpDur;
}

void AlarmSettings::setTime(Time* time) {
  _time = time;
}

Time* AlarmSettings::getTime() {
  return _time;
}

void AlarmSettings::setWakeUpLum(uint8_t wakeUpLum) {
  _wakeUpLum = wakeUpLum;
}

uint8_t AlarmSettings::getWakeUpLum() {
  return _wakeUpLum;
}

Alarm* AlarmSettings::getDayAlarm() {
  return _dayAlarm;
}

WeekAlarm* AlarmSettings::getWeekAlarm() {
  return _weekAlarm;
}

uint8_t AlarmSettings::getAlarmConfigNumber() {
  return _alarmCfgNo;
}

void AlarmSettings::setAlarmConfigNumber(uint8_t no) {
  _alarmCfgNo = no;
}

char* AlarmSettings::getAlarmTitle() {
  return getAlarmTitle(_alarmCfgNo);
}

char* AlarmSettings::getAlarmTitle(uint8_t no) {
  if(no == 7) {
    return _tomorrow;
  }
  else {
    return _time->getDayString(no); //_days[no];
  }
}

uint8_t AlarmSettings::getAlarmHour() {
  return getAlarmHour(_alarmCfgNo);
}

uint8_t AlarmSettings::getAlarmHour(uint8_t no) {
  if(no == 7) {
    return _dayAlarm->getHour();
  }
  else {
    return _weekAlarm->getHour(no);
  }
}

void AlarmSettings::setAlarmHour(uint8_t hour) {
  setAlarmHour(_alarmCfgNo,hour);
}

void AlarmSettings::setAlarmHour(uint8_t no, uint8_t hour) {
  if(no == 7) {
    _dayAlarm->setHour(hour);
  }
  else {
    _weekAlarm->setHour(no,hour);
  }
}

uint8_t AlarmSettings::getAlarmMin() {
  return getAlarmMin(_alarmCfgNo);
}

uint8_t AlarmSettings::getAlarmMin(uint8_t no) {
  if(no == 7) {
    return _dayAlarm->getMin();
  }
  else {
    return _weekAlarm->getMin(no);
  }
}

void AlarmSettings::setAlarmMin(uint8_t min) {
  setAlarmMin(_alarmCfgNo,min);
}

void AlarmSettings::setAlarmMin(uint8_t no,uint8_t min) {
  if(no == 7) {
    _dayAlarm->setMin(min);
  }
  else {
    _weekAlarm->setMin(no,min);
  }
}

bool AlarmSettings::isAlarmActive() {
  return isAlarmActive(_alarmCfgNo);
}

bool AlarmSettings::isAlarmActive(uint8_t no) {
  if(no == 7) {
    return _dayAlarm->isActive();
  }
  else {
    return _weekAlarm->isActive(no);
  }
}

void AlarmSettings::setAlarmActive(bool active) {
  setAlarmActive(_alarmCfgNo,active);
}

void AlarmSettings::setAlarmActive(uint8_t no,bool active) {
  if(no == 7) {
    _dayAlarm->setActive(active);
  }
  else {
    _weekAlarm->setActive(no,active);
  }
}

uint8_t AlarmSettings::getAlarmCount() {
  return 8;
}

uint8_t AlarmSettings::getFirstActiveAlarmNo() {
  uint8_t no = 8;
  uint8_t d = _time->getDay();
  
  //check weekly alarm for today
  if(_weekAlarm->isActive(d)) {
    if(_weekAlarm->getHour(d) > _time->getHour()) {
      no   = d;
    }
    else if(_weekAlarm->getHour(d) == _time->getHour() && _weekAlarm->getMin(d)  >= _time->getMin() ) {
      no   = d;
    }
  }
  
  //check weekly alarm for all days after today
  int i = (d+1)%7;
  while(no == 8 && d != i) {
    if(_weekAlarm->isActive(i)) { 
      no   = i;
    }
    i = (i+1)%7;
  }
  
  //check alarm for 'tomorrow' 
  if(_dayAlarm->isActive()) {
    if(no == d) {  //periodic alarm will be active today, dayAlarm too?
      if( ( _dayAlarm->getHour() >  _time->getHour() ) || 
          ( _dayAlarm->getHour() == _time->getHour() && _dayAlarm->getMin()  >= _time->getMin() ) ) {
        //dayAlarm will also be active today
        if( ( _dayAlarm->getHour() <  _weekAlarm->getHour(no) ) ||
            ( _dayAlarm->getHour() == _weekAlarm->getHour(no) && _dayAlarm->getMin()  <= _weekAlarm->getMin(no) ) ) {
          //but dayAlarm will be first
          no = 7;
        }
      }
    }
    else if(no == (d+1)%7) { //periodic alarm will be active tomorrow, dayAlarm too?
      if( ( _dayAlarm->getHour() <  _time->getHour() ) || 
          ( _dayAlarm->getHour() == _time->getHour() && _dayAlarm->getMin()  <= _time->getMin() ) ) {
        //dayAlarm will also be active tomorrow
        if( ( _dayAlarm->getHour() <  _weekAlarm->getHour(no) ) ||
            ( _dayAlarm->getHour() == _weekAlarm->getHour(no) && _dayAlarm->getMin()  <= _weekAlarm->getMin(no) ) ) {
          //but dayAlarm will be first
          no = 7;
        }
      }
    }
    else { // (no == 8 || no == some day after tomorrow) { //no periodic alarm is found, or first active will be after tomorrow
      no = 7;
    }
  }
  return no;
}

uint8_t AlarmSettings::getSecondActiveAlarmNo() {
  uint8_t no = getFirstActiveAlarmNo();
  if(no == 8) {
    //seek no more
    return no;
  }
  
  uint8_t d = _time->getDay();
  int tm = _time->getHour() * 60 + _time->getMin();
  int alarms[8];
  
  //save for every alarm the time in minutes (if not active, simply save -1)
  for(int i=0;i<7;i++) {
    if(_weekAlarm->isActive(i)) {
      alarms[i] = _weekAlarm->getHour(i) * 60 + _weekAlarm->getMin(i);
    }
    else {
      alarms[i] = -1;
    }
  }
  if(_dayAlarm->isActive()) {
    alarms[7] = _dayAlarm->getHour() * 60 + _dayAlarm->getMin();
  }
  else {
    alarms[7] = -1;
  }
  
  //we're not interested in the first alarm to go off
  alarms[no] = -1;
  
  //calculate for every alarm the amount of minutes left to go off
  for(int i=0;i<7;i++) {
    if(alarms[i] > 0) {
      if(i == d) {
        if( (_weekAlarm->getHour(d) >  _time->getHour() ) ||
            (_weekAlarm->getHour(d) == _time->getHour() && _weekAlarm->getMin(d)  >= _time->getMin()) ) {
          //alarm will go off today
          alarms[i] = alarms[i]-tm;
        }
        else {
          //alarm will go off next week
          alarms[i] = alarms[i]-tm + 10080; // (60*24*7);
        }
      }
      else if(i < d) {
        //alarm will go off next week; we have to count 7-d+i days extra (= days left this week (7-d) + days of next week 
        alarms[i] = alarms[i]-tm + (7-d+i) * 1440; // (60*24)
      }
      else { // (i > d)
        //alarm will go off this week; we have to count i-d days extra (=days left to this day)
        alarms[i] = alarms[i]-tm + (i-d) * 1440; // (60*24)
      }
    }
  }
  if(alarms[7] > 0) {
    if( ( _dayAlarm->getHour() >  _time->getHour() ) || 
        ( _dayAlarm->getHour() == _time->getHour() && _dayAlarm->getMin()  >= _time->getMin() ) ) {
      //dayalarm will be active today
      alarms[7] = alarms[7]-tm;
    }
    else {
      //dayalarm will go off tomorrow
      alarms[7] = alarms[7]-tm + 1440;
    }
  }
  
  //find the lowest value in alarms[] (but not -1)
  no = 8;
  for(int i=0;i<8;i++) {
    if(alarms[i] > 0 && (no == 8 || alarms[i]<alarms[no])) {
      no = i;
    }
  }
  
  return no;
}

uint8_t AlarmSettings::getSnoozeDur() {
  return _snoozeDur;
}

void AlarmSettings::setSnoozeDur(uint8_t dur) {
  _snoozeDur = dur;
}

uint8_t AlarmSettings::getBacklightDur() {
  return _backlightDur;
}

void AlarmSettings::setBacklightDur(uint8_t dur) {
  _backlightDur = dur;
}

void AlarmSettings::setFadeOutDur(uint8_t dur) {
  _fadeOutDur = dur;
}

void AlarmSettings::setFadeOutActive(bool active) {
  _fadeOutActive = active;
}

uint8_t AlarmSettings::getFadeOutDur() {
  return _fadeOutDur;
}

bool AlarmSettings::isFadeOutActive() {
  return _fadeOutActive;
}