Compiler Linker error? : <p>I'm programming for Arduino and since I'm a beginner when I get this error message I'm unable to interpret it in order to solve it.</p>

<p>"<em>C:\Users\VITOR~1.NUN\AppData\Local\Temp\ccmmwX2d.ltrans0.ltrans.o: In function <code>setup':
ccmmwX2d.ltrans0.o:(.text+0x16a): undefined reference to</code>registrador_nivel'
C:\Users\VITOR~1.NUN\AppData\Local\Temp\ccmmwX2d.ltrans4.ltrans.o: In function <code>AutoCampLib::Registrador::debug(char*)':
ccmmwX2d.ltrans4.o:(.text+0xae0): undefined reference to</code>registrador_nivel'
collect2.exe: error: ld returned 1 exit status</em>"</p>

<p><strong>This is my lib :</strong> </p>

<pre><code>    #ifndef LIBAC_H
#define LIBAC_H
#define DEBUG
/***************************************************/
/********************Bibliotecas********************/
/***************************************************/
/*           Biblioteca padrão do Arduino          */
#include &lt;Arduino.h&gt;
/* Bibliotecas de data/hora para módulo DS1307 RTC */
#include &lt;Wire.h&gt;
#include &lt;RTClib.h&gt;
#include &lt;Time.h&gt;
#include &lt;TimeLib.h&gt;
#include &lt;TimeAlarms.h&gt;


/* Bibliotecas de leitura e escrita para módulo SD */
#include &lt;SD.h&gt;
#include &lt;SPI.h&gt;
/*    Biblioteca do módulo ultrassônico HC-SR04    */
#include &lt;Ultrasonic.h&gt;
/*    Biblioteca de Lista Encadeada    */
#include &lt;LinkedList.h&gt;
/*    Biblioteca de Threads    */
#include "Thread.h"
#include "ThreadController.h"

/*    Biblioteca de HashMap    */
#include &lt;HashMap.h&gt;

/***************************************************/
/******************Mapa da Pinagem******************/
/***************************************************/

#define PINO_SD_CS 53
#define setor_1   23
#define setor_2   25
#define setor_3   42
#define setor_4   43
#define setor_5   44
#define setor_6   45
#define setor_7   12
#define setor_8   13
#define setor_9   22
#define setor_10  24
#define setor_11  26
#define setor_12  28
#define setor_13  30
#define setor_14  32
#define setor_15  34
#define DesligaBombaCaptacao 31
#define LigaBombaCaptacao 33
#define DesligaBombaInjec   35
#define LigaBombaInjec  37
#define valvulaDescarte 46
#define DesligaPaMistura    39
#define LigaPaMistura   41
#define silo_1  10
#define silo_2  11
#define valvulaL2   29
#define contraLavagem 27
#define segundosUmaSemana 604800
#define TEMPO_OCIOSO 300
#define pinoInterruptTanque 0   // corresponde ao pino 2
#define pinoInterruptSilo 1     // corresponde ao pino 3
#define pinoInterruptInjec 2    // corresponde ao pino 4
#define pinoSensorTanque    6
#define pinoSensorSilo  5
#define pinoSensorInjec 8    
#define boiaInferior 7
#define boiaSuperior 9 
#define VOLUME_PURGA 100  // em Litros


#define ULTIMA_MENSAGEM "Ultima.msg"
#define SILOS_PRODUTOS "Silos.cfg"
#define PROGRAMACAO "Ferti.cal"
#define CONFIGURACAO "Start.cfg"
#define RETROLAVAGEM "Retrolavagem.cal"
#define DADOS "AutoCamp.nfo"
#define LOG "AutoCamp.log"
#define BACKUP "Backup.log"

namespace AutoCampLib {

    class Mensageiro
    {
        public:
            Mensageiro();
            void lerSerial();
            void enviar1099();

        private:
            bool guardarMensagem(char mensagem[]);
            bool tratarMensagem();
            void tratar2001();
            void tratar2002();
            void tratar2003();
            void tratar2101();
            void tratar2901();
            void tratar2902();
            void tratar2903();
            void tratar2904();
            void tratar2905();
            void tratar2999();
            void enviar1001();
            void enviar1002();
            void enviar1003();
            void enviar1004();
            void enviar1005();
            void lerArquivo(String nome);
            void escreverArquivo(String nome, int identificacao);
            bool verificaLetra(char caracter);
    };

    class Registrador
    {
        public:
            static void debug(char mensagem[]);
            static void info(char mensagem[]);
            static void warn(char mensagem[]);
            static void error(char mensagem[]);

        private:
            static void escreverRegistro(char mensagem[],char tipo[]);
            static void verificarTamanho();
            static String buscarDataHora();
    };

    class Fertilizantes
    {
        public :
            void setSilo(char *s);
            void setVol(float volumeFert);
            char *getSilo();
            float getVol();
            void setPortaSilo(int portasilo);
            int getPortaSilo();


        private :
            char _silo[8];
            float volumeF;
            int _portasilo;
    };

    class Eventos
    {
        public :
            Eventos();
            void setSetor(int setor);
            void setDuracao(int duracao);
            void setSequencial(int sequencial);
            void setVolumeH2O(float volumeAgua);
            void setPorta(int porta);
            int getPorta();
            int getSetor();
            int getDuracao();
            int getSequencial();
            float getVolumeH2O();
            //void setFertilizantes(LinkedList&lt;Fertilizantes*&gt;);
            //LinkedList&lt;Fertilizantes*&gt; getFertilizantes();
            Fertilizantes* getFertilizante(int posicao);
            void addFertilizante(Fertilizantes* fertilizante);
            int sizeFertilizantes();



        private :
            int _setor;
            int _porta;
            float _duracao;
            int _sequencial;
            float _volumeH2O;
            LinkedList&lt;Fertilizantes*&gt; _fertilizantes;
    };

    class Agendamentos
    {
        public:
            Agendamentos();
            void setDia(int dia);
            void setHora(int hora);
            void setMinuto(int minuto);
            void setSegundo(int segundo);
            int getDia();
            int getHora();
            int getMinuto();
            int getSegundo();
            //LinkedList&lt;Eventos*&gt; getEventos();
            Eventos* getEvento(int posicao);
            void addEvento(Eventos* evento);
            int sizeEventos();

        private :
            int _dia;
            int _hora;
            int _minuto;
            int _segundo;
            int posicao;
            LinkedList&lt;Eventos*&gt; _eventos;
    };

    class Start 
    {

        public :
            void setPressurizacao (int pressurizacao);
            void setTroca (int troca);
            void setInjecao(int injecao);
            void setAtraso( int atraso);
            void setOrdem(int ordem);
            void setBase(float base);
            void setTopo(float topo);
            void setAltura(float altura);
            void setSiloSTART(char *p);
            void setPino(int pino);
            void openReadStart(Start *start);
            void leCaracter(char c, File file);

            int getPressurizacao();
            int getTroca();
            int getInjecao();
            int getAtraso();
            int getOrdem();
            float getBase();
            float getTopo();
            float getAltura();
            char *getSiloSTART();
            int getPino();

        private :
            Start *start;
            File startcfg;
            int pr;
            int troca;
            int inj;
            int atraso;
            int seq;
            int pino;
            float base;
            float topo;
            float altura;
            char charLido;

            int _pressurizacao;
            int _troca;
            int _injecao;
            int _atraso;
            int _ordem;
            float _base;
            float _topo;
            float _altura;
            char _silostart[8];
            int _pino;
    };


   class Util 
   {

        public :
            static double calculaVolume(byte sensorInterrupt,byte sensorPin, float volumeDesejado);
            static void contadorPulso();

   }; 


   class SensorNivel: public Thread 
    {
        public : bool shouldRun(long time);
                 void run();

        private : int estado;    
    };


    class Programas: public Thread
    {
        public :   bool shouldRun(long time);
                   void run();

        private :  unsigned long tempo;
                   DateTime now ;
    };

    class RecuperaIrriga: public Thread
    {
        public : 
                 bool shouldRun(long time);
                 void run(); 
                 void fecharTodoSetor();
                 void verificarSetores(int numSetor);

        private : long horaFim;
                  long horaAtual;
                  long horaAgendamento;
                  int numeroEvento;
                  DateTime now;
                  Agendamentos *agendamento;

    }; 


    class VolumeAgua: public Thread
    {
        public :
                  bool shouldRun(long time);
                  void run();
                  static void contadorPulso();
                  double calculaVolume(byte sensorInterrupt,byte sensorPin, float volumeDesejado);

        private : volatile byte contaPulso; 
                  int numeroFert;
                  int numeroEvento;
                  float taxaFluxo;
                  float fatorCalibrador;
                  unsigned int fluxoL;
                  unsigned long totalL;
                  unsigned long oldTime;
    };

    class VolumeSilo: public Thread
    {
        public :
                    bool shouldRun(long time);
                    void run();

                    static void contadorPulso();
                    double calculaVolume(byte sensorInterrupt,byte sensorPin, float volumeDesejado);

        private :   float fatorCalibrador;
                    volatile byte contaPulso;
                    int numeroEvento;
                    int numeroFert;    
                    float taxaFluxo;
                    unsigned int fluxoL;
                    unsigned long totalL;
                    unsigned long oldTime;      
    };


    class RecuperaFerti: public Thread
    {
        public : 
                  void verificarSetores(int numSetor);
                  void run();
                  bool shouldRun(long time);


        private : long horaAtual;
                  long inicio;
                  int encherTanque;
                  long horaAgendamento;
                  int encherSilo;
                  int numeroFert;
                  int numeroEvento;
                  DateTime now;
                  Agendamentos *agendamento;


    }; 

    class RecuperaSilos: public Thread
    {

        public :   bool shouldRun(long time);
                   void run(); 

        private :  int numeroFert;
                   int numeroEvento; 

    }; 

    class Injecao: public Thread 
    {

        public : bool shouldRun(long time);
                 void run();   


        private : int numeroFert;
                  int numeroEvento;
                  int estado;
    };                   

    class NivelInjec: public Thread
    {
        private : int estado;

        public : bool shouldRun(long time);
                 void run();   
    };

    class Purga: public Thread
    {
        public :  void run();
                  bool shouldRun(long time);
                  static void contadorPulso();
                  double calculaVolume(byte sensorInterrupt,byte sensorPin, float volumeDesejado);      
    };


    class NivelPurga: public Thread
    {
        private : int estado;
                  DateTime now;
                  int numeroEvento;
                  long horaAtual;
                  long horaAgendamento;
                  Agendamentos *agendamento;

        public : bool shouldRun(long time);
                 void run();
                 fecharTodoSetor();   
    };





}

using namespace AutoCampLib;
#endif
</code></pre>
