'si5351_init' was not declared in this scope

jcberberena · December 23, 2024, 7:36pm

Please,
Can someone help me with this issued.-------------
Here is the ino file `Use code tags to format code for the forum`

#include <Wire.h>
#include "si5351.h"
#include <Rotary.h>
#include <EEPROM.h>
#include "OneButton.h"


// S meter glyphs
unsigned long previousMillis = 0;
unsigned long starttime = 0;
unsigned long currentMillis = millis();

/*-------------------------
   PIN ASSIGNMENT ADIBA PCB
  --------------------------*/
#define BAND1 0     // Pin 30  MW
#define BAND2 1     // pin 31  80M
#define BAND3 2     // pin 32  40M
#define BAND4 3     // pin 1   20M
#define BAND5 4     // pin 2   15M
#define BAND6 5     // pin 9   10M
#define LCD_SCL 6   // pin 10
#define LCD_SDA 7   // pin 11
#define ABCD 8      // pin 12
#define ROT_A 11    // pin 15
#define ROT_B 12    // pin 16
#define STEP  13    // pin 17                                                                                                   
#define PTT A0      // pin 23

#define LSB_PIN 10  // pin 14
#define USB_PIN 15  // pin 24 A1
#define AM_PIN 16   // pin 25 A2
#define s_meter  A7   //        // pin 22
const byte analog_button = A6;  // pin 19


Rotary r = Rotary(ROT_A, ROT_B) ;


/*----------------------
   GLOBAL VARIABLE
  ----------------------*/
long fstep = 1000;
int Step = 2;
int _Step = 2;
int flag_step = 0;
int steprom = 1;
int Calstep = 1;
long Cal = 0;
long Calstp;
int mode = 0;
int _mode = 0;
int set = 0;
int _set = 0;
int band = 2;
int _band = 2;
int band_max = 5;
int vfo = 1;
int _vfo = 1;
int romadd = 0;
int analogdata = 0;
int value = 0;
int _value = 0;
int ifstep = 100000;
int bandmax = 6;
int bandold = 2;
int fritold = 0;
long freqrit = 0;
long fritmax = 5000;
long fritmin = -5000;
int flagmode = 0;
int flagband = 0;
int flagif = 0;
int flagrit = 0;
int flagCal = 0;

/*-----------------
      FLAG
  ---------------*/
int flag_set = 0;
int flag_tx = 0;
int flag_mode = 0;
int flag_band = 0;
int flag_if = 0;
int flag_rit = 0;
int flag_cal = 0;
int flag_corr = 0;

unsigned long romf[4];
unsigned long freq = 7050000; // frekuensi awal
unsigned long freq_max = 7300000;
unsigned long freq_min = 6900000;
unsigned long _freq = 0;

long IF_freq = 9000000;
long _IF_freq = 9000000;
long freq_rit = 0;
String freqt = String(freq);
long xtal_corr = 0;
long _xtal_corr = 0;
unsigned long dds_freq = 0;
unsigned long _fxtal;
long correction = 0;
long _correction = 0;
unsigned char f_carON = 1;     // ON/OFF Car signal


/*---------------/
   VOLT METER
  /---------------*/
const byte volt_meter = A3;
float Vout = 0.00 ;
float Vin = 0.00 ;
float Volt_to_Disp = 0;
float R1 = 15000.00;
float R2 = 500.00;
int val = 0;

/*---------------------------------------------------
  IF frequency Shift setting
  ----------------------------------------------------*/

int32_t USB    = +1500;    // offset 1500 Hz over IF freq
int32_t LSB    = -1500;    // offset 1500Hz below IF freq
int32_t CW     = -800;     // 800 Hz below IF freq
int32_t TX_CW   = 0;        // no offset
int32_t AM     = 0;        // no offset


byte D1, D2, D3, D4, D5, D6, D7;
byte IFD1, IFD2, IFD3, IFD4, IFD5, IFD6, IFD7;
byte CalD1, CalD2, CalD3;

unsigned char Mask1[] = {0x5f, 0x50, 0x6b, 0x79, 0x74, 0x3d, 0x3f, 0x58, 0x7f, 0x7d};
unsigned char Mask2[] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
unsigned char Mask3[] = {0xdf, 0xd0, 0xeb, 0xf9, 0xf4, 0xbd, 0xbf, 0xd8, 0xff, 0xfd};

unsigned char l_data[20];
unsigned char s1, s2, s3;
unsigned char z_addr[] =
{
  26, 7, 28, 7, 30, 7, 32, 7, 34, 7, 36, 7, 38, 7, 0, 3, 0, 2, 0, 0,
  0, 1, 24, 7, 22, 7, 20, 7, 0, 6, 12, 6, 12, 5, 12, 4, 12, 1, 12, 3,
  12, 2, 12, 7, 2, 4, 0, 7, 12, 0, 2, 5, 2, 7, 2, 2, 2, 0, 0, 4,
  0, 5, 2, 6, 2, 3, 2, 1, 16, 7, 18, 7, 14, 7, 10, 4, 10, 5, 10, 6,
  10, 7, 10, 3, 10, 2, 10, 1, 10, 0, 8, 4, 8, 5, 8, 6, 8, 7, 8, 3,
  8, 2, 8, 1, 8, 0, 6, 4, 6, 5, 6, 6, 6, 7, 6, 3, 6, 2, 6, 1,
  6, 0, 4, 4, 4, 5, 4, 6, 4, 7, 4, 3, 4, 2, 4, 0, 4, 1
};

//const int analogPin = A6;
int current_barCount = 0;
int last_barCount = 0;

int_fast32_t timepassed = millis(); // int to hold the arduino miilis since startup
int ForceFreq = 0;  // Change this to 0 after you upload and run a working sketch to activate the EEPROM memory.  YOU MUST PUT THIS BACK TO 0 AND UPLOAD THE SKETCH AGAIN AFTER STARTING FREQUENCY IS SET!
String freq1; // string to hold the frequency
String m_band;
String m_mode;
String IFfreq;
String Calfx;
int memstatus = 1;  // value to notify if memory is current or old. 0=old, 1=current.



//===============================
void setup()
{ 
  delay(100);
  analogReference(DEFAULT);
  Serial.begin(9600);
  si5351_init();
  pinMode(BAND1, OUTPUT);
  pinMode(BAND2, OUTPUT);
  pinMode(BAND3, OUTPUT);
  pinMode(BAND4, OUTPUT);
  pinMode(BAND5, OUTPUT);
  pinMode(BAND6, OUTPUT);
  pinMode(LSB_PIN, OUTPUT);
  pinMode(USB_PIN, OUTPUT);
  pinMode(AM_PIN, OUTPUT);
  pinMode(STEP, INPUT_PULLUP);
  pinMode(ROT_A, INPUT_PULLUP);
  pinMode(ROT_B, INPUT_PULLUP);
  pinMode(volt_meter, INPUT);
  pinMode(PTT, INPUT_PULLUP);
  pinMode(s_meter, INPUT);
  PCICR += (1 << PCIE0);
  PCMSK0 += (1 << PCINT3) | (1 << PCINT4);
  sei();
  lcdreset();
  Clear(0x0);
  if (ForceFreq == 0) {
    freq1 = String(EEPROM.read(0)) + String(EEPROM.read(1)) + String(EEPROM.read(2)) + String(EEPROM.read(3)) + String(EEPROM.read(4)) + String(EEPROM.read(5)) + String(EEPROM.read(6));
    freq = freq1.toInt();
    m_band = String(EEPROM.read(7));
    band = m_band.toInt();
    m_mode = String(EEPROM.read(8));
    mode = m_mode.toInt();
    IFfreq = String(EEPROM.read(10)) + String(EEPROM.read(11)) + String(EEPROM.read(12)) + String(EEPROM.read(13)) + String(EEPROM.read(14)) + String(EEPROM.read(15)) + String(EEPROM.read(16));
    IF_freq = IFfreq.toInt();
    Calfx = String(EEPROM.read(17)) + String(EEPROM.read(18)) + String(EEPROM.read(19));
    Cal = Calfx.toInt();
    //set_freq_xtal(Cal);
  }
  l_data[z_addr[70] / 2] |= Mask2[z_addr[70 + 1]];
  f_wd1(z_addr[70], l_data[z_addr[70] / 2]);
  l_data[z_addr[68] / 2] |= Mask2[z_addr[68 + 1]];
  f_wd1(z_addr[68], l_data[z_addr[68] / 2]);
  l_data[z_addr[26] / 2] |= Mask2[z_addr[26 + 1]];
  f_wd1(z_addr[26], l_data[z_addr[26] / 2]);
  show_step();
  show_vfo();
  show_band(band);
}

/*-------------------------------------
    MAIN PROGRAM
  ----------------------------------*/
void loop() {
  display_s_meter();
  val = analogRead(volt_meter);// baca analog input
  Vout = (val * 1.1) / 1024.00; // formula utk menghitung V out V+, di sini 5V
  Vin = Vout / (R2 / (R1 + R2)); // formula utk menghitung V in thd GND

  if (Vin < 0.09)
  {
    Vin = 0.00;
  }
  if (Vin != 0.00) {
    Volt_to_Disp = Vin * 10;
    delay(500);
  }
  show_volt(Volt_to_Disp);
  show_mode();
  analogdata = analogRead(analog_button);
  if ( analogdata < 50) {
    set_mode();
  }
  else if (analogdata < 600) {
    set_dds();
  }
  else if (analogdata < 700 && flag_set != 1) {
    chg_vfo();
  }
  else if (analogdata < 900 && flag_set != 1) {
    if ( flag_tx != 1) {
      set_band();
    }
  }
  if (digitalRead(STEP) == LOW && flag_set != 1) {
    set_step();
  }
  if (freq != _freq) {
    show_freq(freq);
    _freq = freq;
    //set_freq(freq + IF_freq + LSB );
    //set_car_freq(IF_freq + LSB, f_carON, 0);
  }

    if (memstatus == 0) {
    if (timepassed + 10000 < millis()) {
      storeMEM();
    }
  }
}


/*----------------
     SET MODE
  ---------------*/
void set_mode() {
  if (flag_tx != 1 && flag_set != 1) {
    _mode = mode + 1;
    if (_mode > 3) {
      _mode = 0;
    }
    if (mode != _mode) {
      mode = _mode;
      show_mode();
      show_freq(freq);
      while (analogRead(analog_button) < 1000);
    }
  }
}
void show_mode() {
  if (flag_tx != 1) {
    if (mode == 0) {
      l_data[z_addr[2] / 2] |= Mask2[z_addr[2 + 1]];
      f_wd1(z_addr[2], l_data[z_addr[2] / 2]);
    }
    else if (mode == 1) {
      l_data[z_addr[4] / 2] |= Mask2[z_addr[4 + 1]];
      f_wd1(z_addr[4], l_data[z_addr[4] / 2]);
    }
    else if (mode == 2) {
      l_data[z_addr[6] / 2] |= Mask2[z_addr[6 + 1]];
      f_wd1(z_addr[6], l_data[z_addr[6] / 2]);
    }
    else if (mode == 3) {
      l_data[z_addr[8] / 2] |= Mask2[z_addr[8 + 1]];
      f_wd1(z_addr[8], l_data[z_addr[8] / 2]);
    }
  }
}

/*-----------------
     SET STEP
  -----------------*/
void set_step() {
  _Step = Step + 1;
  if ( _Step > 5) {
    _Step = 0;
  }
  if (Step != _Step)
    Step = _Step;
  show_step();
  while (digitalRead(STEP) == LOW);
}
void show_step() {
  f_fill1(0, 2);
  f_fill1(0, 0);
  if ( Step == 0) {
    fstep = 10;
    l_data[z_addr[60] / 2] |= Mask2[z_addr[60 + 1]]; // placing underscore @ 10Hz
    f_wd1(z_addr[60], l_data[z_addr[60] / 2]);
    l_data[z_addr[44] / 2] |= Mask2[z_addr[44 + 1]]; // placing hundred thousands desimal point
    f_wd1(z_addr[44], l_data[z_addr[44] / 2]);
    l_data[z_addr[46] / 2] |= Mask2[z_addr[46 + 1]]; // plasing hundreds decimal point
    f_wd1(z_addr[46], l_data[z_addr[46] / 2]);

  }
  if ( Step == 1) {
    fstep = 100;
    l_data[z_addr[58] / 2] |= Mask2[z_addr[58 + 1]]; // placing underscore @ 100Hz
    f_wd1(z_addr[58], l_data[z_addr[58] / 2]);
    l_data[z_addr[44] / 2] |= Mask2[z_addr[44 + 1]]; // placing hundred thousands desimal point
    f_wd1(z_addr[44], l_data[z_addr[44] / 2]);
    l_data[z_addr[46] / 2] |= Mask2[z_addr[46 + 1]]; // plasing hundreds decimal point
    f_wd1(z_addr[46], l_data[z_addr[46] / 2]);
  }

  if ( Step == 2) {
    fstep = 1000;
    l_data[z_addr[56] / 2] += Mask2[z_addr[56 + 1]];  // placing underscore @ 1k
    f_wd1(z_addr[56], l_data[z_addr[56] / 2]);
    l_data[z_addr[44] / 2] += Mask2[z_addr[44 + 1]]; // placing hundred thousands desimal point
    f_wd1(z_addr[44], l_data[z_addr[44] / 2]);
    l_data[z_addr[46] / 2] += Mask2[z_addr[46 + 1]]; // plasing hundreds decimal point
    f_wd1(z_addr[46], l_data[z_addr[46] / 2]);
  }

  if (Step == 3) {
    fstep = 10000;
    l_data[z_addr[54] / 2] |= Mask2[z_addr[54 + 1]]; // placing underscore @ 10k
    f_wd1(z_addr[54], l_data[z_addr[54] / 2]);
    l_data[z_addr[44] / 2] |= Mask2[z_addr[44 + 1]]; // placing hundred thousands desimal point
    f_wd1(z_addr[44], l_data[z_addr[44] / 2]);
    l_data[z_addr[46] / 2] |= Mask2[z_addr[46 + 1]]; // plasing hundreds decimal point
    f_wd1(z_addr[46], l_data[z_addr[46] / 2]);
  }

  if (Step == 4 ) {
    fstep = 100000;
    l_data[z_addr[52] / 2] |= Mask2[z_addr[52 + 1]]; // placing underscore @ 100k
    f_wd1(z_addr[52], l_data[z_addr[52] / 2]);
    l_data[z_addr[44] / 2] |= Mask2[z_addr[44 + 1]]; // placing hundred thousands desimal point
    f_wd1(z_addr[44], l_data[z_addr[44] / 2]);
    l_data[z_addr[46] / 2] |= Mask2[z_addr[46 + 1]]; // plasing hundreds decimal point
    f_wd1(z_addr[46], l_data[z_addr[46] / 2]);
  }

  if (Step == 5) {
    fstep = 1000000;
    l_data[z_addr[50] / 2] |= Mask2[z_addr[50 + 1]]; // placing underscore @ 1M
    f_wd1(z_addr[50], l_data[z_addr[50] / 2]);
    l_data[z_addr[44] / 2] |= Mask2[z_addr[44 + 1]]; // placing hundred thousands desimal point
    f_wd1(z_addr[44], l_data[z_addr[44] / 2]);
    l_data[z_addr[46] / 2] |= Mask2[z_addr[46 + 1]]; // plasing hundreds decimal point
    f_wd1(z_addr[46], l_data[z_addr[46] / 2]);
  }
}

/*--------------
   SET DDS
  ------------*/
void set_dds() {
  _set = set + 1;
  if ( _set > 1) {
    _set = 0;
  }
  if (set != _set) {
    set = _set;
    show_set();
    show_correction(correction);
    while (analogRead(analog_button) < 1000);
  }
}

void show_set() {
  f_fill1(0, 1);
  f_fill1(0, 0);
  if ( set == 1 ) {
    flag_corr = 1;
    flag_set = 1;
    l_data[z_addr[20] / 2] |= Mask2[z_addr[20 + 1]];
    f_wd1(z_addr[20], l_data[z_addr[20] / 2]);
    l_data[z_addr[44] / 2] |= Mask2[z_addr[44 + 1]];
    f_wd1(z_addr[44], l_data[z_addr[44] / 2]);
    l_data[z_addr[46] / 2] |= Mask2[z_addr[46 + 1]];
    f_wd1(z_addr[46], l_data[z_addr[46] / 2]);
  }
  else {
    set = 0;
    flag_set = 0;
    l_data[z_addr[44] / 2] |= Mask2[z_addr[44 + 1]];
    f_wd1(z_addr[44], l_data[z_addr[44] / 2]);
    l_data[z_addr[46] / 2] |= Mask2[z_addr[46 + 1]];
    f_wd1(z_addr[46], l_data[z_addr[46] / 2]);
  }
}

/*-------------------/
  /   CHANGE VFO A/B   /
  /-------------------*/
void chg_vfo() {
  _vfo = vfo + 1;
  if ( _vfo > 3 ) {
    _vfo = 1;
  }
  if ( vfo != _vfo) {
    vfo = _vfo;
    show_vfo();
    while (analogRead(analog_button) < 1000);
  }
}

void show_vfo() {
  //  f_fill1(30,0);
  //  f_fill1(0, 0);
  if (vfo == 1) {
    f_fill1(0, 12);
    f_fill1(0, 0);
    l_data[z_addr[30] / 2] |= Mask2[z_addr[30 + 1]];
    f_wd1(z_addr[30], l_data[z_addr[30] / 2]);
    l_data[z_addr[46] / 2] |= Mask2[z_addr[46 + 1]];
    f_wd1(z_addr[46], l_data[z_addr[46] / 2]);
  }
  if (vfo == 2) {
    f_fill1(0, 12);
    f_fill1(0, 0);
    l_data[z_addr[32] / 2] |= Mask2[z_addr[32 + 1]];
    f_wd1(z_addr[32], l_data[z_addr[32] / 2]);
    l_data[z_addr[46] / 2] |= Mask2[z_addr[46 + 1]];
    f_wd1(z_addr[46], l_data[z_addr[46] / 2]);
  }
  if (vfo == 3) {
    f_fill1(0, 12);
    f_fill1(0, 0);
    l_data[z_addr[34] / 2] |= Mask2[z_addr[34 + 1]];
    f_wd1(z_addr[34], l_data[z_addr[34] / 2]);
    l_data[z_addr[46] / 2] |= Mask2[z_addr[46 + 1]];
    f_wd1(z_addr[46], l_data[z_addr[46] / 2]);
  }
}

//----------  Encorder procedure(INT)  ---------------
ISR (PCINT0_vect) {
  unsigned char result = r.process();
  if (result) {
    if (result == DIR_CW) {
      freq += fstep;
      if (freq >= 29999999) {
        freq = 29999999;
      }
    }
    else {
      freq -= fstep;
      if (freq <= 540000) {
        freq = 540000;
      }
    }
  }
}

void wait()
{
}
void f_start() {
  pinMode(LCD_SCL, OUTPUT);
  pinMode(LCD_SDA, OUTPUT);
  digitalWrite (LCD_SDA, 1);
  wait;
  digitalWrite (LCD_SCL, 1);
  wait;
  digitalWrite (LCD_SDA, 0);
  wait;
  digitalWrite (LCD_SCL, 0);
}

void f_stop()
{
  pinMode(LCD_SCL, OUTPUT);
  pinMode(LCD_SDA, OUTPUT);
  digitalWrite (LCD_SDA, 0);
  wait;
  digitalWrite (LCD_SCL, 1);
  wait;
  digitalWrite (LCD_SDA, 1);
  wait;
  digitalWrite (LCD_SCL, 0);
}
byte IICCACK()
{
  byte l_bit;
  pinMode (LCD_SCL, OUTPUT);
  pinMode (LCD_SDA, OUTPUT);
  digitalWrite (LCD_SCL, 1);
  wait;
  digitalWrite (LCD_SDA, 1);
  wait;
  pinMode (LCD_SDA, INPUT);
  l_bit = digitalRead (LCD_SDA) ;
  wait;
  wait;
  digitalWrite(LCD_SCL, 0);
  return l_bit;
}

void f_bit(byte l_bit) {
  pinMode(LCD_SCL, OUTPUT);
  pinMode(LCD_SDA, OUTPUT);
  digitalWrite(LCD_SDA, l_bit);
  wait;
  wait;
  digitalWrite(LCD_SCL, 1);
  wait;
  digitalWrite(LCD_SCL, 0);
  wait;
  digitalWrite(LCD_SDA, 0);
}

void f_byte_rrc(unsigned char l_byte)
{
  unsigned char i;

  for (i = 0; i < 8; i++)
  { if ((l_byte & 0x1) == 0x1)
      f_bit(1);
    else
      f_bit(0);
    l_byte >>= 1;
  }
}

void f_byte(unsigned char l_byte)
{ unsigned char i;
  for (i = 0; i < 8; i++)
  { if ((l_byte & 0x80) == 0x80)
      f_bit(1);
    else
      f_bit(0);
    l_byte <<= 1;
  }
}

void f_wc(unsigned char l_ICCS, unsigned char l_ICDATA)
{ f_start();
  f_byte(0x70);
  if (IICCACK() == 0)
    f_byte(l_ICCS);
  if (IICCACK() == 0)
    f_byte(l_ICDATA);
  f_stop();
}

void f_wd1(unsigned char l_ICADDR, unsigned char l_ICDATA)
{
  l_data[l_ICADDR / 2] = l_ICDATA;
  f_start();
  f_byte(0x70);
  if (IICCACK() == 0)
    f_byte(0xe0);
  if (IICCACK() == 0)
    f_byte(l_ICADDR);
  if (IICCACK() == 0)
    f_byte_rrc(l_ICDATA);
  f_stop();
}

void Clear_addr1(unsigned char l_ICADDR, unsigned char l_ICDATA)
{
  l_data[l_ICADDR / 2] = l_ICDATA;
  f_start();
  f_byte(0x70);
  if (IICCACK() == 0)
    f_byte(0xe0);
  if (IICCACK() == 0)
    f_byte_rrc(l_ICDATA);
  f_stop();
}

void f_fill1(unsigned char h, unsigned char dat)
{
  f_wd1(dat, h);
}

void Clear(unsigned char h)
{
  unsigned char i;
  for (i = 0; i < 40; i += 2)
    f_wd1(i, h);
}

void Clear_bar(unsigned char h)
{
  unsigned char i;
  for (i = 4; i < 12; i += 2)
    f_wd1(i, h);
}

void lcdreset()
{ f_wc(0xe0, 0x48);
  f_wc(0xe0, 0x70);
}

/*-----------------
   SHOW FREQUENCY ( routine to display frequency
  -------------------*/
void show_freq(long data) {
  D1 = (data / 10000000);
  D2 = ((data / 1000000) % 10);
  D3 = ((data / 100000) % 10);
  D4 = ((data / 10000) % 10);
  D5 = ((data / 1000) % 10);
  D6 = ((data / 100) % 10);
  D7 = ((data / 10) % 10);
  if (freq > 9999999) {
    f_wd1(26, Mask1[D1]);
    if (mode == 0)      {
      f_wd1(28, Mask3[D2]);
      f_wd1(30, Mask1[D3]);
      f_wd1(32, Mask1[D4]);
      f_wd1(34, Mask1[D5]);
    }
    else if (mode == 1) {
      f_wd1(28, Mask1[D2]);
      f_wd1(30, Mask3[D3]);
      f_wd1(32, Mask1[D4]);
      f_wd1(34, Mask1[D5]);
    }
    else if (mode == 2) {
      f_wd1(28, Mask1[D2]);
      f_wd1(30, Mask1[D3]);
      f_wd1(32, Mask3[D4]);
      f_wd1(34, Mask1[D5]);
    }
    else if (mode == 3) {
      f_wd1(28, Mask1[D2]);
      f_wd1(30, Mask1[D3]);
      f_wd1(32, Mask1[D4]);
      f_wd1(34, Mask3[D5]);
    }
    f_wd1(36, Mask1[D6]);
    f_wd1(38, Mask1[D7]);
  }
  else {
    f_wd1(26, 0); if (mode == 0) {
      f_wd1(28, Mask3[D2]);
      f_wd1(30, Mask1[D3]);
      f_wd1(32, Mask1[D4]);
      f_wd1(34, Mask1[D5]);
    }
    else if (mode == 1) {
      f_wd1(28, Mask1[D2]);
      f_wd1(30, Mask3[D3]);
      f_wd1(32, Mask1[D4]);
      f_wd1(34, Mask1[D5]);
    }
    else if (mode == 2) {
      f_wd1(28, Mask1[D2]);
      f_wd1(30, Mask1[D3]);
      f_wd1(32, Mask3[D4]);
      f_wd1(34, Mask1[D5]);
    }
    else if (mode == 3 )  {
      f_wd1(28, Mask1[D2]);
      f_wd1(30, Mask1[D3]);
      f_wd1(32, Mask1[D4]);
      f_wd1(34, Mask3[D5]);
    }
    f_wd1(36, Mask1[D6]);
    f_wd1(38, Mask1[D7]);
  }
  l_data[z_addr[26] / 2] |= Mask2[z_addr[26 + 1]];
  f_wd1(z_addr[26], l_data[z_addr[26] / 2]);
}

/*-----------------
   SHOW IF FREQUENCY ( routine to display frequency
  -------------------*/
void show_IFfreq(long data) {
  IFD1 = (data / 10000000);
  IFD2 = ((data / 1000000) % 10);
  IFD3 = ((data / 100000) % 10);
  IFD4 = ((data / 10000) % 10);
  IFD5 = ((data / 1000) % 10);
  IFD6 = ((data / 100) % 10);
  IFD7 = ((data / 10) % 10);
  if (IF_freq > 9999999) {
    f_wd1(26, Mask1[D1]);
    if (mode == 0)      {
      f_wd1(28, Mask3[D2]);
      f_wd1(30, Mask1[D3]);
      f_wd1(32, Mask1[D4]);
      f_wd1(34, Mask1[D5]);
    }
    else if (mode == 1) {
      f_wd1(28, Mask1[D2]);
      f_wd1(30, Mask3[D3]);
      f_wd1(32, Mask1[D4]);
      f_wd1(34, Mask1[D5]);
    }
    else if (mode == 2) {
      f_wd1(28, Mask1[D2]);
      f_wd1(30, Mask1[D3]);
      f_wd1(32, Mask3[D4]);
      f_wd1(34, Mask1[D5]);
    }
    else if (mode == 3) {
      f_wd1(28, Mask1[D2]);
      f_wd1(30, Mask1[D3]);
      f_wd1(32, Mask1[D4]);
      f_wd1(34, Mask3[D5]);
    }
    f_wd1(36, Mask1[D6]);
    f_wd1(38, Mask1[D7]);
  }
  else {
    f_wd1(26, 0); if (mode == 0) {
      f_wd1(28, Mask3[D2]);
      f_wd1(30, Mask1[D3]);
      f_wd1(32, Mask1[D4]);
      f_wd1(34, Mask1[D5]);
    }
    else if (mode == 1) {
      f_wd1(28, Mask1[D2]);
      f_wd1(30, Mask3[D3]);
      f_wd1(32, Mask1[D4]);
      f_wd1(34, Mask1[D5]);
    }
    else if (mode == 2) {
      f_wd1(28, Mask1[D2]);
      f_wd1(30, Mask1[D3]);
      f_wd1(32, Mask3[D4]);
      f_wd1(34, Mask1[D5]);
    }
    else if (mode == 3 )  {
      f_wd1(28, Mask1[D2]);
      f_wd1(30, Mask1[D3]);
      f_wd1(32, Mask1[D4]);
      f_wd1(34, Mask3[D5]);
    }
    f_wd1(36, Mask1[D6]);
    f_wd1(38, Mask1[D7]);
  }
  l_data[z_addr[26] / 2] |= Mask2[z_addr[26 + 1]];
  f_wd1(z_addr[26], l_data[z_addr[26] / 2]);
}

/*-----------------
   SHOW CORRECTION (routine to display x-tal correction value
  -------------------*/
void show_correction(long corr) {

  D1 = (corr / 100);
  D2 = ((corr / 10) % 10);
  D3 = ((corr / 1) % 10);
  if (correction > 99) {
    f_wd1(20, Mask1[D1]);
    f_wd1(22, Mask1[D2]);
    f_wd1(24, Mask1[D3]);

  }
  if (correction < 100) {
    f_wd1(20, 0);
    f_wd1(22, Mask1[D2]);
    f_wd1(24, Mask1[D3]);
  }
  if (correction < 10) {
    f_wd1(20, 0);
    f_wd1(22, 0);
    f_wd1(24, Mask1[D3]);
  }
  if (set == 0) {
    f_wd1(20, 0);
    f_wd1(22, 0);
    f_wd1(24, 0);
  }
}

/*---------------------/
  / SHOW VOLTAGE Routine /
  /---------------------*/
void show_volt(long Volt_to_Disp) {
  D1 = (Volt_to_Disp / 100);
  D2 = ((Volt_to_Disp / 10) % 10);
  D3 = ((Volt_to_Disp / 1) % 10);
  if (Vin < 1000) {
    f_wd1(14, Mask1[D1]);
    f_wd1(16, Mask3[D2]);
    f_wd1(18, Mask3[D3]);
  }
  if (Vin < 100) {
    f_wd1(14, Mask1[D1]);
    f_wd1(16, Mask3[D2]);
    f_wd1(18, Mask3[D3]);
  }
}

/*-------------------------
    SHOW BAND NBR
  ------------------------*/
void show_band(int band) {
  D1 = ((band / 1) + 1);
  f_wd1(24, Mask1[D1]);
}
/*-----------------------*/

//void f_dd()
//{ unsigned char i, k;
//  for (k = 0; k < 9; k++)
//  { for (i = 14; i < 40; i += 2)
//      f_wd1(i, Mask1[k]);
//  }
//}

/*----------------------
   X-Tal Calibratin
  --------------------*/
void set_cal() {
  if ( flag_cal == 1) {
    flag_cal = 0;
    flag_rit = 0;
  }
  else {
    flag_cal = flag_cal + 1;
  }
}
void show_cal() {
  char str[64];
  if ( flag_cal == 1) {
    flag_rit == 0;

  }
  else if ( flag_cal == 0) {
    //   storeMEM();
  }
}
/*-----------------------------------------------------------------------------------------------
        storeMEM
  ------------------------------------------------------------------------------------------------*/
void storeMEM() {
  //Write each frequency section to a EPROM slot.  Yes, it's cheating but it works!

  EEPROM.write(0, D1);
  EEPROM.write(1, D2);
  EEPROM.write(2, D3);
  EEPROM.write(3, D4);
  EEPROM.write(4, D5);
  EEPROM.write(5, D6);
  EEPROM.write(6, D7);
  EEPROM.write(7, band);
  EEPROM.write(8, mode);
  EEPROM.write(10, IFD1);
  EEPROM.write(11, IFD2);
  EEPROM.write(12, IFD3);
  EEPROM.write(13, IFD4);
  EEPROM.write(14, IFD5);
  EEPROM.write(15, IFD6);
  EEPROM.write(16, IFD7);
  EEPROM.write(17, CalD1);
  EEPROM.write(18, CalD2);
  EEPROM.write(19, CalD3);
  //  EEPROM.commit();
  memstatus = 1;  // Let program know memory has been written
  
}

/*----------------------
   BAND SWITCH
  -----------------------*/
void set_band() {
  digitalWrite(BAND1, LOW);
  digitalWrite(BAND2, LOW);
  digitalWrite(BAND3, LOW);
  digitalWrite(BAND4, LOW);
  digitalWrite(BAND5, LOW);
  digitalWrite(BAND6, LOW);
  if (flag_tx != 1 && flag_set != 1) {
    _band = band + 1;
    if (_band > 5) {
      _band = 0;
    }
    band = _band;
    while (analogRead(analog_button) < 1000);
  }
  switch (band)
  {
    case 0: freq = 720000   ; fstep = 9000; mode = 2; break;
    case 1: freq = 3700000  ; fstep = 1000; mode = 0; break;
    case 2: freq = 7050000  ; fstep = 1000; mode = 0; break;
    case 3: freq = 14074000 ; fstep = 1000; mode = 1; break;
    case 4: freq = 21074000 ; fstep = 1000; mode = 1; break;
    case 5: freq = 28074000 ; fstep = 1000; mode = 1; break;
  }
  show_band(band);
}

/*-------------------------
   DISPLAY S METER
  -------------------*/
void display_s_meter() {
  //  value = analogRead(s_meter);
  current_barCount = map(analogRead(s_meter), 0, 1023, 0, 76); // mapping s.d 76 hanya siasat gar jumlah maks bar 60 address ( 30 led) terpenuhi karena input analognya di pasng devider
  if (current_barCount > 60) { // barCount tidak boleh melebihi jumlah bar address (60)
    current_barCount = 60;     // bila melebihi maka akn mengganggu tampilan
  }
  if (current_barCount % 2 ) { // barCount hrus selalu genap agar bisa dipergunkan
    current_barCount += 1;     // untuk menghapus current_barCount saat bergerak ke kiri
  }
  if (current_barCount > last_barCount) {
    for (int i = 74; i < 74 + current_barCount ; i += 2) {
      l_data[z_addr[i] / 2] |= Mask2[z_addr[i + 1]];
      f_wd1(z_addr[i], l_data[z_addr[i] / 2]);
    }
    last_barCount = current_barCount;
  }
  else if ( current_barCount < last_barCount) {
    //  for (int i = 74 + current_barCount ; i < 134 ; i +=2) { // salah, tidk bisa menggunakn nilai maksimum address sesuai jumlah bar .
    for (int i = 74 + current_barCount ; i < 74 + last_barCount ; i += 2) { // ternyata selama ini salah logika menghitungnya 134 adalah maksimum bar, seharusnya adalah minimum bar + current_barCount
      l_data[z_addr[i] / 2] -= Mask2[z_addr[i + 1]];  // -= berfungsi menghapus nilai z-addres[i] pada sat bar bergerak ke kanan
      f_wd1(z_addr[i], l_data[z_addr[i] / 2]);
      delay(1);
    }
    last_barCount = current_barCount;
  }
}
````Use code tags to format code for the forum`

xfpd · December 23, 2024, 7:38pm

Please, post the full error and either the contents of file si5351.h or a link to it. You might have an out dated .ino or .h.

b707 · December 23, 2024, 7:51pm

@jcberberena
Is it your code? If not - please show the link to original project.

MrY · December 23, 2024, 8:07pm

You did not create an instance of the class. This is demonstrated here.

When you call the init method for si5351, you need to pass in some arguments as demonstrated here.

You have other bugs in your program. The Rotary class has no method called process.

pert · December 23, 2024, 10:09pm

I moved your topic to an appropriate forum category @jcberberena .

In the future, please take some time to pick the forum category that best suits the subject of your topic. There is an "About the _____ category" topic at the top of each category that explains its purpose.

This is an important part of responsible forum usage, as explained in the "How to get the best out of this forum" guide. The guide contains a lot of other useful information. Please read it.

Thanks in advance for your cooperation.

jcberberena · December 23, 2024, 11:24pm

It is the only code I have, I do not have other one

xfpd · December 24, 2024, 2:43am

It looks like you have a HAM sketch. My guess is you are using this library by NT7S...

github.com

NT7S/Si5351/blob/master/si5351.h

/*
 * si5351.h - Si5351 library for avr-gcc
 *
 * Copyright (C) 2014 Jason Milldrum <milldrum@gmail.com>
 *
 * Many defines derived from clk-si5351.h in the Linux kernel.
 * Sebastian Hesselbarth <sebastian.hesselbarth@gmail.com>
 * Rabeeh Khoury <rabeeh@solid-run.com>
 *
 * do_div() macro derived from /include/asm-generic/div64.h in
 * the Linux kernel.
 * Copyright (C) 2003 Bernardo Innocenti <bernie@develer.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of

This file has been truncated. show original

jcberberena · December 24, 2024, 2:49am

using library Jason Milldrum I got another kind of message:
Compilation error: exit status 1

xfpd · December 24, 2024, 2:53am

Show the full error. (and un-check "solution" in post #2)

Topic		Replies	Views
GPS + Si5351A + I2C LCD Education	5	796	September 29, 2024
Stampare su display variabile con puntini migliaia Software	18	140	March 7, 2026
Strange Boolean problem Programming	44	1036	October 1, 2023
Error whit compiling can any one helpe? Programming	8	57	April 15, 2026
SI5351 with Nano. Controlling outputs with digital pin? General Guidance	6	641	July 8, 2025

'si5351_init' was not declared in this scope

Please, Can someone help me with this issued.------------- Here is the ino file Use code tags to format code for the forum

Related topics

Please,
Can someone help me with this issued.-------------
Here is the ino file `Use code tags to format code for the forum`