not able to get alarm from max31341b

[tejasVyas]

im trying to write drivers of max31341 external rtc, where i been able to successfully able to set time (starting rtc also) in rtc and get time from rtc, so not im trying to get alarm signal from rtc in every one second, my using alarm 1 from max31341 and im writing drivers in zephyr and im taking reference of arduino drivers, can plz revive my code and see what im doing wrong.

#include <zephyr/kernel.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/device.h>
#include <zephyr/devicetree.h>
#include <zephyr/sys/printk.h>
#include <zephyr/drivers/gpio.h>
#include <time.h>

#include <sys/types.h>
#include <sys/timespec.h>

#define SW0_NODE DT_ALIAS(sw5)

static const struct gpio_dt_spec button = GPIO_DT_SPEC_GET(SW0_NODE, gpios);
#define I2C_NODE DT_NODELABEL(max31341)

#define MAX31341_R_CFG1 0x00
#define MAX31341_R_CFG2 0x01
#define MAX31341_R_INT_EN 0x04
#define MAX31341_R_INT_STATUS (0x05)
#define MAX31341_REG_SECONDS 0x06
#define MAX31341_REG_PWR_MGMT 0x56
#define MAX31341_REG_TRICKLE 0x57
#define MAX31341_R_ALM1_SEC 0x0D
#define MAX31341_R_ALM2_MIN 0x11


#define GET_BIT_VAL(val, pos, mask)     ( ( (val) & mask) >> pos )
#define SET_BIT_VAL(val, pos, mask)     ( ( ((int)val) << pos) & mask )

#define BCD2BIN(val) (((val) & 15) + ((val) >> 4) * 10)
#define BIN2BCD(val) ((((val) / 10) << 4) + (val) % 10)
struct tm rtc_ctime;

/**
 * @brief	Alarm number selection
 */
typedef enum
{
        ALARM1, /**< Alarm number 1 */
        ALARM2, /**< Alarm number 2 */
} alarm_no_t;
/**
 * @brief  Property of the bits.
 */

typedef enum
{

        _DISABLE = 0,
        _ENABLE = 1,

} bit_property_t;

/**
 * @brief	Analog comparator threshold voltage
 */
typedef enum
{
        COMP_THRESH_1V3, /**< 1.3V */
        COMP_THRESH_1V7, /**< 1.7V */
        COMP_THRESH_2V0, /**< 2.0V */
        COMP_THRESH_2V2, /**< 2.2V */
} comp_thresh_t;

/**
 * @brief	Supply voltage select.
 */
typedef enum
{
        POW_MGMT_SUPPLY_SEL_AUTO, /**< Circuit decides whether to use VCC or VBACKUP */
        POW_MGMT_SUPPLY_SEL_VCC,  /**< Use VCC as supply */
        POW_MGMT_SUPPLY_SEL_AIN,  /**< Use AIN as supply */
} power_mgmt_supply_t;
/**
 * @brief	Alarm periodicity selection
 */
typedef enum
{
        ALARM_PERIOD_EVERYSECOND, /**< Once per second */
        ALARM_PERIOD_EVERYMINUTE, /**< Second match / Once per minute */
        ALARM_PERIOD_HOURLY,      /**< Second and Minute match */
        ALARM_PERIOD_DAILY,       /**< Hour, Minute and Second match*/
        ALARM_PERIOD_WEEKLY,      /**< Day and Time match */
        ALARM_PERIOD_MONTHLY      /**< Date and Time match */
} alarm_period_t;

typedef union
{
        uint8_t raw;
        struct
        {
                uint8_t a1f : 1;
                uint8_t a2f : 1;
                uint8_t tif : 1;
                uint8_t : 1;
                uint8_t eif1 : 1;
                uint8_t ana_if : 1;
                uint8_t osf : 1;
                uint8_t los : 1;
        } bits;
} reg_status_t;

/**
 * @brief	Selection of interrupt ids
 */
typedef enum
{
        INTR_ID_ALARM1,   /**< Alarm1 flag */
        INTR_ID_ALARM2,   /**< Alarm2 flag */
        INTR_ID_TIMER,    /**< Timer interrupt flag */
        INTR_ID_RESERVED, /**< RESERVED */
        INTR_ID_EXTERNAL, /**< External interrupt flag for DIN1 */
        INTR_ID_ANALOG,   /**< Analog Interrupt flag / Power fail flag  */
        INTR_ID_OSF,      /**< Oscillator stop flag */
        INTR_ID_LOS,      /**< Loss of signal */
        INTR_ID_END,
} intr_id_t;

typedef enum
{
        TRICKLE_CHARGER_3K,        /**< 3000 Ohm */
        TRICKLE_CHARGER_6K = 0x02, /**< 6000 Ohm */
        TRICKLE_CHARGER_11K,       /**< 11000 Ohm */
} trickle_charger_ohm_t;

/**
 * @brief	Selection of INTB/CLKOUT pin function
 */
typedef enum
{
        CONFIGURE_PIN_AS_CLKOUT, /**< Output is square wave */
        CONFIGURE_PIN_AS_INTB,   /**< Output is interrupt   */
} config_intb_clkout_pin_t;

/**
 * @brief	Mode of the comparator
 */
typedef enum
{
        POW_MGMT_MODE_COMPARATOR,       /**< Comparator */
        POW_MGMT_MODE_POWER_MANAGEMENT, /**< Power Management / Trickle Charger Mode */
} power_mgmt_mode_t;

typedef union
{
        uint8_t raw;
        struct
        {
                uint8_t swrstn : 1; /**< Software reset */
                uint8_t rs : 2;     /**< Square wave output frequency selection on CLKOUT pin */
                uint8_t osconz : 1; /**< Oscillator is on when set to 0. Oscillator is off when set to 1. */
                uint8_t clksel : 2; /**< Selects the CLKIN frequency */
                uint8_t intcn : 1;  /**< Interrupt control bit. Selects the direction of INTB/CLKOUT */
                uint8_t eclk : 1;   /**< Enable external clock input */
        } bits;
} config_reg1_t;

typedef union
{
        uint8_t raw;
        struct
        {
                uint8_t : 1;             /**< Unused */
                uint8_t set_rtc : 1;     /**< Set RTC */
                uint8_t rd_rtc : 1;      /**< Read RTC. */
                uint8_t i2c_timeout : 1; /**< I2C timeout Enable */
                uint8_t bref : 2;        /**< BREF sets the analog comparator threshold voltage. */
                uint8_t data_reten : 1;  /**< Sets the circuit into data retention mode. */
                uint8_t : 1;
        } bits;
} config_reg2_t;

typedef struct
{
        union
        {
                uint8_t raw;
                struct
                {
                        uint8_t seconds : 4; /**< Alarm1 seconds */
                        uint8_t sec_10 : 3;  /**< Alarm1 seconds in multiples of 10 */
                        uint8_t axm1 : 1;    /**< Alarm1 mask bit for minutes */
                } bits;
                struct
                {
                        uint8_t value : 7;
                        uint8_t : 1;
                } bcd;
        } sec;

        union
        {
                uint8_t raw;
                struct
                {
                        uint8_t minutes : 4; /**< Alarm1 minutes */
                        uint8_t min_10 : 3;  /**< Alarm1 minutes in multiples of 10 */
                        uint8_t axm2 : 1;    /**< Alarm1 mask bit for minutes */
                } bits;
                struct
                {
                        uint8_t value : 7;
                        uint8_t : 1;
                } bcd;
        } min;

        union
        {
                uint8_t raw;
                struct
                {
                        uint8_t hour : 4;  /**< Alarm1 hours */
                        uint8_t hr_10 : 2; /**< Alarm1 hours in multiples of 10 */
                        uint8_t : 1;
                        uint8_t axm3 : 1; /**< Alarm1 mask bit for hours */
                } bits;
                struct
                {
                        uint8_t value : 6;
                        uint8_t : 2;
                } bcd;
        } hrs;

        union
        {
                uint8_t raw;
                struct
                {
                        uint8_t day_date : 4; /**< Alarm1 day/date */
                        uint8_t date_10 : 2;  /**< Alarm1 date in multiples of 10 */
                        uint8_t dy_dt : 1;
                        uint8_t axm4 : 1; /**< Alarm1 mask bit for day/date */
                } bits;
                struct
                {
                        uint8_t value : 3;
                        uint8_t : 5;
                } bcd_day;
                struct
                {
                        uint8_t value : 6;
                        uint8_t : 2;
                } bcd_date;
        } day_date;
} regs_alarm_t;

typedef union
{
        uint8_t raw;
        struct
        {
                uint8_t d_mode : 2;      /**< Sets the mode of the comparator to one of the two following:
                                          comparator mode, and power management mode/trickle charger mode. */
                uint8_t d_man_sel : 1;   /**< Default low. When this bit is low, input control block decides
                                          which supply to use. When this bit is high, user can manually
                                          select whether to use V<sub>CC</sub> or VBACKUP as supply. */
                uint8_t d_vback_sel : 1; /**< Default low. When this bit is low, and D_MANUAL_SEL is high,
                                          V<sub>CC</sub> is switched to supply. When this bit is high,
                                          and D_MANUAL_SEL is high, V<sub>BACKUP</sub> is switched to supply.*/
                uint8_t : 4;             /**< Unused */
        } bits;
} pwr_mgmt_reg_t;

typedef struct
{
        union
        {
                uint8_t raw;
                struct
                {
                        uint8_t seconds : 4; /**< RTC seconds value. */
                        uint8_t sec_10 : 3;  /**< RTC seconds in multiples of 10 */
                        uint8_t : 1;
                } bits;
                struct
                {
                        uint8_t value : 7;
                        uint8_t : 1;
                } bcd;
        } seconds;

        union
        {
                uint8_t raw;
                struct
                {
                        uint8_t minutes : 4; /**< RTC minutes value */
                        uint8_t min_10 : 3;  /**< RTC minutes in multiples of 10 */
                        uint8_t : 1;
                } bits;
                struct
                {
                        uint8_t value : 7;
                        uint8_t : 1;
                } bcd;
        } minutes;

        union
        {
                uint8_t raw;
                struct
                {
                        uint8_t hour : 4;  /**< RTC hours value */
                        uint8_t hr_10 : 2; /**< RTC hours in multiples of 10 */
                        uint8_t : 2;
                } bits;
                struct
                {
                        uint8_t value : 6;
                        uint8_t : 2;
                } bcd;
        } hours;

        union
        {
                uint8_t raw;
                struct
                {
                        uint8_t day : 3; /**< RTC days */
                        uint8_t : 5;
                } bits;
                struct
                {
                        uint8_t value : 3;
                        uint8_t : 5;
                } bcd;
        } day;

        union
        {
                uint8_t raw;
                struct
                {
                        uint8_t date : 4;    /**< RTC date */
                        uint8_t date_10 : 2; /**< RTC date in multiples of 10 */
                        uint8_t : 2;
                } bits;
                struct
                {
                        uint8_t value : 6;
                        uint8_t : 2;
                } bcd;
        } date;

        union
        {
                uint8_t raw;
                struct
                {
                        uint8_t month : 4;    /**< RTC months */
                        uint8_t month_10 : 1; /**< RTC month in multiples of 10 */
                        uint8_t : 2;
                        uint8_t century : 1; /**< Century bit */
                } bits;
                struct
                {
                        uint8_t value : 5;
                        uint8_t : 3;
                } bcd;
        } month;

        union
        {
                uint8_t raw;
                struct
                {
                        uint8_t year : 4;    /**< RTC years */
                        uint8_t year_10 : 4; /**< RTC year multiples of 10 */
                } bits;
                struct
                {
                        uint8_t value : 8;
                } bcd;
        } year;
} regs_rtc_time_t;

int sw_reset_assert(const struct i2c_dt_spec *max31341)
{
        int ret;
        uint8_t val8;
        uint8_t tempReg[2] = {MAX31341_R_CFG1};

        ret = i2c_write_read_dt(max31341, &tempReg[0], 1, &val8, 1);
        if (ret)
        {
                return ret;
        }
        val8 = val8 & ~(1 << 0);
        tempReg[1] = val8;
        ret = i2c_write_dt(max31341, tempReg, sizeof(tempReg));

        if (ret)
        {
                return ret;
        }
        return 0;
}
int sw_reset_release(const struct i2c_dt_spec *max31341)
{
        int ret;
        uint8_t val8;
        uint8_t tempReg[2] = {MAX31341_R_CFG1};

        ret = i2c_write_read_dt(max31341, &tempReg[0], 1, &val8, 1);
        if (ret)
        {
                return ret;
        }
        val8 = val8 | (1 << 0);
        tempReg[1] = val8;
        ret = i2c_write_dt(max31341, tempReg, sizeof(tempReg));

        if (ret)
        {
                return ret;
        }
        return 0;
}
int max31341RtcStart(const struct i2c_dt_spec *max31341)
{
        int ret;
        uint8_t val8;
        uint8_t tempReg[2] = {MAX31341_R_CFG1};

        ret = i2c_write_read_dt(max31341, &tempReg[0], 1, &val8, 1);
        if (ret)
        {
                return ret;
        }
        val8 = val8 & ~(1 << 3);
        tempReg[1] = val8;
        ret = i2c_write_dt(max31341, tempReg, sizeof(tempReg));
        if (ret)
        {
                return ret;
        }
        return 0;
}
int max31341_disable_interrupt(const struct i2c_dt_spec *max31341)
{
        int ret;
        uint8_t tempReg[2] = {MAX31341_R_INT_EN};
        uint8_t val;
        ret = i2c_write_read_dt(max31341, &tempReg[0], 1, &val, 1);
        val = val & ~((1 << 0) | (1 << 1) | (1 << 2) | (1 << 4) | (1 << 5) | (1 << 6));
        tempReg[1] = val;
        ret = i2c_write_dt(max31341, tempReg, sizeof(tempReg));
        if (ret)
        {
                return ret;
        }
        return 0;
}
int max31341_external_clock(const struct i2c_dt_spec *max31341, bit_property_t bit)
{
        int ret;
        uint8_t val8;
        uint8_t tempReg[2] = {MAX31341_R_CFG1};
        config_reg1_t oldConfig;
        ret = i2c_write_read_dt(max31341, &tempReg[0], 1, &oldConfig.raw, 1);
        if (ret)
        {
                return ret;
        }
        oldConfig.bits.eclk = bit;
        tempReg[1] = oldConfig.raw;
        ret = i2c_write_dt(max31341, tempReg, sizeof(tempReg));

        if (ret)
        {
                return ret;
        }
        return 0;
}
int max31341_comparator_threshold_level(const struct i2c_dt_spec *max31341, comp_thresh_t th)
{
        int ret;
        uint8_t val8;
        uint8_t tempReg[2] = {MAX31341_R_CFG1};
        config_reg2_t oldConfig;
        ret = i2c_write_read_dt(max31341, &tempReg[0], 1, &oldConfig.raw, 1);
        if (ret)
        {
                return ret;
        }
        oldConfig.bits.bref = th;
        tempReg[1] = oldConfig.raw;
        ret = i2c_write_dt(max31341, tempReg, sizeof(tempReg));
        if (ret)
        {
                return ret;
        }
        return 0;
}

static int i2c_timeout_config(const struct i2c_dt_spec *max31341, int enable)
{
        int ret;
        uint8_t val8;
        uint8_t tempReg[2] = {MAX31341_R_CFG1};
        config_reg2_t oldConfig;
        ret = i2c_write_read_dt(max31341, &tempReg[0], 1, &oldConfig.raw, 1);
        if (ret)
        {
                return ret;
        }
        oldConfig.bits.i2c_timeout = (enable) ? 1 : 0;
        tempReg[1] = oldConfig.raw;
        ret = i2c_write_dt(max31341, tempReg, sizeof(tempReg));
        if (ret)
        {
                return ret;
        }

        return 0;
}
int max31341_supply_select(const struct i2c_dt_spec *max31341, power_mgmt_supply_t supply)
{
        int ret;
        pwr_mgmt_reg_t reg;
        if (MAX31341_REG_PWR_MGMT == 0xff)
        {
                return ret;
        }
        uint8_t tempReg[2] = {MAX31341_REG_PWR_MGMT};
        ret = i2c_write_read_dt(max31341, &tempReg[0], 1, &reg.raw, 1);
        if (ret)
        {
                ret;
        }
        switch (supply)
        {
        case POW_MGMT_SUPPLY_SEL_VCC:
                reg.bits.d_man_sel = 1;
                reg.bits.d_vback_sel = 0;
                break;

        case POW_MGMT_SUPPLY_SEL_AIN:
                reg.bits.d_man_sel = 1;
                reg.bits.d_vback_sel = 1;
                break;

        case POW_MGMT_SUPPLY_SEL_AUTO:

        default:
                reg.bits.d_man_sel = 0;
                break;
        }
        tempReg[1] = reg.raw;
        ret = i2c_write_dt(max31341, tempReg, sizeof(tempReg));
        if (ret)
        {
                return ret;
        }
        return 0;
}

int max31341_set_power_mgmt_mode(const struct i2c_dt_spec *max31341, power_mgmt_mode_t mode)
{
        int ret;
        pwr_mgmt_reg_t reg;
        if (MAX31341_REG_PWR_MGMT == 0xff)
        {
                return ret;
        }
        uint8_t tempReg[2] = {MAX31341_REG_PWR_MGMT};
        ret = i2c_write_read_dt(max31341, &tempReg[0], 1, &reg.raw, 1);
        if (ret)
        {
                ret;
        }
        reg.bits.d_mode = mode;
        tempReg[1] = reg.raw;
        ret = i2c_write_dt(max31341, tempReg, sizeof(tempReg));
        if (ret)
        {
                return ret;
        }
        return 0;
}

int max31341_trickle_charger_enable(const struct i2c_dt_spec *max31341, trickle_charger_ohm_t res, bool diode)
{
        int ret;
        struct
        {

                unsigned char ohm : 2;
                unsigned char diode : 1;
                unsigned char schottky : 1;
                unsigned char : 4;
        } reg;
        if (MAX31341_REG_TRICKLE == 0xff)
        {

                return ret;
        }
        reg.ohm = res;
        reg.diode = (diode) ? 1 : 0;
        reg.schottky = 1; /* always enabled */
        uint8_t tempReg[2] = {MAX31341_REG_TRICKLE};
        tempReg[1] = (uint8_t *)®
        ret = i2c_write_dt(max31341, tempReg, sizeof(tempReg));
        if (ret)
        {
                return ret;
        }
        return 0;
}
int max31341_configure_intb_clkout_pin(const struct i2c_dt_spec *max31341, config_intb_clkout_pin_t sel)
{
        int ret;
        uint8_t val8;
        uint8_t tempReg[2] = {MAX31341_R_CFG1};
        config_reg1_t oldConfig;
        ret = i2c_write_read_dt(max31341, &tempReg[0], 1, &oldConfig.raw, 1);
        if (ret)
        {
                return ret;
        }
        oldConfig.bits.intcn = (sel == CONFIGURE_PIN_AS_INTB) ? 1 : 0;
        printk("val ->%d\n", oldConfig.bits.intcn);
        tempReg[1] = oldConfig.raw;
        ret = i2c_write_dt(max31341, tempReg, sizeof(tempReg));

        if (ret)
        {
                return ret;
        }
        k_msleep(20);
        return 0;
}
/** Enable INTERRUPT on INTB **/
int max31341_irq_enable(const struct i2c_dt_spec *max31341, intr_id_t id)
{
        int ret;
        uint8_t reg;
        uint8_t tempReg[2] = {MAX31341_R_INT_EN};
        ret = i2c_write_read_dt(max31341, &tempReg[0], 1, &reg, 1);
        if (ret)
        {
                return ret;
        }
        reg = reg | 1 << id;
        tempReg[1] = reg;
        ret = i2c_write_dt(max31341, tempReg, sizeof(tempReg));
        if (ret)
        {
                return ret;
        }
        ret = i2c_write_read_dt(max31341, &tempReg[0], 1, &reg, 1);
        if (ret)
        {
                return ret;
        }
        printk("%d \n", reg);
        return 0;
}

int max31341Init(const struct i2c_dt_spec *max31341)
{
        int ret = sw_reset_assert(max31341);
        if (ret)
        {
                printk("soft reset failed1\n");
                return -1;
        }
        k_msleep(10);
        ret = sw_reset_release(max31341);
        if (ret)
        {
                printk("soft reset failed2\n");
                return -1;
        }
        ret = max31341RtcStart(max31341);
        if (ret)
        {
                printk("rtc start failed\n");
                return -1;
        }
        ret = max31341_external_clock(max31341, _DISABLE);
        if (ret)
        {
                printk("external clock set failed failed\n");
                return -1;
        }
        // max31341_comparator_threshold_level(max31341, COMP_THRESH_2V2);
        // 2c_timeout_config(max31341, 1);
        ret = max31341_supply_select(max31341, POW_MGMT_SUPPLY_SEL_AUTO);
        if (ret)
        {
                printk("POW_MGMT_SUPPLY_SEL_AUTO error \n");
                return -1;
        }
        ret = max31341_disable_interrupt(max31341);
        if (ret)
        {
                printk("disable interrupt failed\n");
                return -1;
        }

        return 0;
}
int max31341_set_time(const struct i2c_dt_spec *max31341, struct tm *time)
{
        int ret;
        regs_rtc_time_t regs;

        if (time == NULL)
        {
                return -1;
        }
        regs.seconds.bcd.value = BIN2BCD(time->tm_sec);
        regs.minutes.bcd.value = BIN2BCD(time->tm_min);
        regs.hours.bcd.value = BIN2BCD(time->tm_hour);
        regs.day.bcd.value = BIN2BCD(time->tm_wday + 1);
        regs.date.bcd.value = BIN2BCD(time->tm_mday);
        regs.month.bcd.value = BIN2BCD(time->tm_mon + 1);

        if (time->tm_year >= 200)
        {
                regs.month.bits.century = 1;
                regs.year.bcd.value = BIN2BCD(time->tm_year - 200);
        }
        else if (time->tm_year >= 100)
        {
                regs.month.bits.century = 0;
                regs.year.bcd.value = BIN2BCD(time->tm_year - 100);
        }
        else
        {
                // Invalid set date!
                return -1;
        }
        uint8_t data[sizeof(regs_rtc_time_t) + 1] = {MAX31341_REG_SECONDS};
        data[1] = regs.seconds.bcd.value;
        data[2] = regs.minutes.bcd.value;
        data[3] = regs.hours.bcd.value;
        data[4] = regs.day.bcd.value;
        data[5] = regs.date.bcd.value;
        data[6] = regs.month.bcd.value;
        data[7] = regs.year.bcd.value;
        ret = i2c_write_dt(max31341, data, sizeof(regs) + 1);
        if (ret)
        {
                printk("setting rtc error\n");
                return -1;
        }
        uint8_t tempReg[2] = {MAX31341_REG_SECONDS};
        ret = i2c_write_read_dt(max31341, &tempReg[0], 1, &regs.seconds.raw, 1);
        if (ret)
        {
                printk("reading regs sec problem\n");
                return -1;
        }
        printk("%d", regs.seconds.raw);
        /*
         *  Set RTC
         */
        uint8_t val8;
        //  uint8_t tempReg[2] = {MAX31341_R_SECONDS};
        tempReg[0] = MAX31341_R_CFG2;
        ret = i2c_write_read_dt(max31341, &tempReg[0], 1, &val8, 1);
        if (ret)
        {
                printk("reading problem\n");
                return -1;
        }
        val8 &= ~(1 << 1);
        tempReg[1] = val8;
        ret = i2c_write_dt(max31341, tempReg, sizeof(tempReg));
        if (ret)
        {
                printk("writing problem in config 2 reg\n");
                return -1;
        }
        k_msleep(10);
        val8 |= (1 << 1);
        tempReg[1] = val8;

        ret = i2c_write_dt(max31341, tempReg, sizeof(tempReg));
        if (ret)
        {
                printk("writing in config 2 problem\n");
                return -1;
        }
        /* SET_RTC bit should be kept high at least 10ms */
        k_msleep(10);
        val8 &= ~(1 << 1);
        tempReg[1] = val8;
        ret = i2c_write_dt(max31341, tempReg, sizeof(tempReg));
        if (ret)
        {
                printk("reading problem\n");
                return -1;
        }
        return 0;
}

int max31341_get_time(const struct i2c_dt_spec *max31341, struct tm *time)
{
        int ret;
        regs_rtc_time_t regs;

        if (time == NULL)
        {
                return -1;
        }
        uint8_t tempReg[2] = {MAX31341_REG_SECONDS};
        ret = i2c_write_read_dt(max31341, &tempReg[0], 1, &regs, sizeof(regs));
        if (ret)
        {
                printk("reading regs sec problem\n");
                return -1;
        }

        /* tm_sec seconds [0,61] */
        time->tm_sec = BCD2BIN(regs.seconds.bcd.value);
        /* tm_min minutes [0,59] */
        time->tm_min = BCD2BIN(regs.minutes.bcd.value);
        /* tm_hour hour [0,23] */
        time->tm_hour = BCD2BIN(regs.hours.bcd.value);
        /* tm_wday day of week [0,6] (Sunday = 0) */
        time->tm_wday = BCD2BIN(regs.day.bcd.value) - 1;
        /* tm_mday day of month [1,31] */
        time->tm_mday = BCD2BIN(regs.date.bcd.value);
        /* tm_mon month of year [0,11] */
        time->tm_mon = BCD2BIN(regs.month.bcd.value) - 1;

        /* tm_year years since 2000 */
        if (regs.month.bits.century)
        {
                time->tm_year = BCD2BIN(regs.year.bcd.value) + 200;
        }
        else
        {
                time->tm_year = BCD2BIN(regs.year.bcd.value) + 100;
        }

        /* tm_yday day of year [0,365] */
        time->tm_yday = 0; /* TODO */
        /* tm_isdst daylight savings flag */
        time->tm_isdst = 0; /* TODO */
        printk("time -> ");
        printk("%d:", time->tm_hour);
        printk("%d:", time->tm_min);
        printk("%d \n", time->tm_sec);
        printk("data -> ");
        printk("%d/", time->tm_mday);
        printk("%d/", time->tm_mon);
        printk("%d \n", time->tm_year + 1900);
        return 0;
}
int max31341_set_alarm(const struct i2c_dt_spec *max31341, const struct tm *alarm_time, alarm_period_t period, alarm_no_t at)
{
        int ret;
        regs_alarm_t regs;

        if (at == ALARM2 && (period == ALARM_PERIOD_EVERYSECOND))
        {
                return -1;
        }

        /*
         *  Set period
         */
        regs.sec.bits.axm1 = 1;
        regs.min.bits.axm2 = 1;
        regs.hrs.bits.axm3 = 1;
        regs.day_date.bits.axm4 = 1;
        regs.day_date.bits.dy_dt = 1;
        switch (period)
        {
        case ALARM_PERIOD_EVERYSECOND:
                // Do nothing
                break;
        case ALARM_PERIOD_EVERYMINUTE:
                regs.sec.bits.axm1 = 0;
                break;
        case ALARM_PERIOD_HOURLY:
                regs.sec.bits.axm1 = 0;
                regs.min.bits.axm2 = 0;
                break;
        case ALARM_PERIOD_DAILY:
                regs.sec.bits.axm1 = 0;
                regs.min.bits.axm2 = 0;
                regs.hrs.bits.axm3 = 0;
                break;
        case ALARM_PERIOD_WEEKLY:
                regs.sec.bits.axm1 = 0;
                regs.min.bits.axm2 = 0;
                regs.hrs.bits.axm3 = 0;
                regs.day_date.bits.axm4 = 0;
                break;
        case ALARM_PERIOD_MONTHLY:
                regs.sec.bits.axm1 = 0;
                regs.min.bits.axm2 = 0;
                regs.hrs.bits.axm3 = 0;
                regs.day_date.bits.axm4 = 0;
                regs.day_date.bits.dy_dt = 0;
                break;
        default:
                return -1;
        }

        /*
         * Convert time structure to alarm registers
         */
        regs.sec.bcd.value = BIN2BCD(alarm_time->tm_sec);
        regs.min.bcd.value = BIN2BCD(alarm_time->tm_min);
        regs.hrs.bcd.value = BIN2BCD(alarm_time->tm_hour);

        if (regs.day_date.bits.dy_dt == 0)
        {
                /* Date match */
                regs.day_date.bcd_date.value = BIN2BCD(alarm_time->tm_mday);
        }
        else
        {
                /* Day match */
                regs.day_date.bcd_day.value = BIN2BCD(alarm_time->tm_wday);
        }

        uint8_t *ptr_regs = (uint8_t *)&regs;
        uint8_t tempReg[2] = {MAX31341_R_ALM1_SEC};
        if (at == ALARM1)
        {
                tempReg[1] = ptr_regs[0];
                ret = i2c_write_dt(max31341, tempReg, sizeof(regs) + 1);
        }
        else
        {
                tempReg[0] = MAX31341_R_ALM2_MIN;
                tempReg[1] = ptr_regs[1];
                ret = i2c_write_dt(max31341, tempReg, sizeof(tempReg) - 1);
        }
        return ret;
}
int get_alarm(const struct i2c_dt_spec *dev, alarm_no_t alarm_no, struct tm *alarm_time, alarm_period_t *period)
{
        /*
         *  Convert alarm registers to time structure
         */
        int ret;
        regs_alarm_t regs;
        uint8_t *ptr_regs = (uint8_t *)&regs;
        uint8_t temp[2] = {MAX31341_R_ALM1_SEC};
        ret = i2c_write_read_dt(dev, &temp[0], 1, &regs, sizeof(regs));
        alarm_time->tm_sec = BCD2BIN(regs.sec.bcd.value);
        printk("%d \n", regs.sec.raw);
        return ret;
}
int max31341_irq_clear_flag(const struct i2c_dt_spec *max31341, intr_id_t id)
{
        int ret;
        uint8_t val;
        uint8_t temp[2] = {
            MAX31341_R_INT_STATUS,
        };
        ret = i2c_write_read_dt(max31341, temp, 1, &val, 1);
        printk("value is %d\n", val);
        return 0;
}
int max31341_get_status(const struct i2c_dt_spec *dev, reg_status_t *stat)
{
        int ret;
        uint8_t val8;
        uint8_t temp[2] = {MAX31341_R_INT_STATUS};

        ret = i2c_write_read_dt(dev, &temp[0], 1, &val8, 1);
        if (ret)
        {
                return ret;
        }
        stat->bits.a1f = GET_BIT_VAL(val8, 0, 1 << 0);
        stat->bits.a2f = GET_BIT_VAL(val8, 1, 1 << 1);
        stat->bits.tif = GET_BIT_VAL(val8, 2, 1 << 2);
        stat->bits.eif1 = GET_BIT_VAL(val8, 4, 1 << 4);
        stat->bits.ana_if = GET_BIT_VAL(val8, 5, 1 << 5);
        stat->bits.osf = GET_BIT_VAL(val8, 6, 1 << 6);
        stat->bits.los = GET_BIT_VAL(val8, 7, 1 << 7);
        return 0;
}

volatile int dataReady = 0;
static struct gpio_callback button_cb_data;
static const struct i2c_dt_spec max31341 = I2C_DT_SPEC_GET(I2C_NODE);

void button_pressed(const struct device *dev, struct gpio_callback *cb, uint32_t pins)
{
        dataReady = 1;
        printk("interrupt triggered\n");
        max31341_irq_enable(&max31341, ALARM1);
}

int main()
{
        int ret;
        ret = gpio_pin_configure_dt(&button, GPIO_INPUT);
        ret = gpio_pin_interrupt_configure_dt(&button, GPIO_INT_EDGE_TO_ACTIVE);
        if (!device_is_ready(max31341.bus))
        {
                printk("device not ready\n");
                return -1;
        }
        ret = max31341Init(&max31341);
        if (ret)
        {
                printk("failed to init max31341\n");
                return -1;
        }
        rtc_ctime.tm_year = 124; // years since 1900
        rtc_ctime.tm_mon = 6;    // 0-11
        rtc_ctime.tm_mday = 8;   // 1-31
        rtc_ctime.tm_hour = 10;  // 0-23
        rtc_ctime.tm_min = 22;   // 0-59
        rtc_ctime.tm_sec = 0;    // 0-61
        rtc_ctime.tm_yday = 0;   // 0-365
        rtc_ctime.tm_wday = 0;   // 0-6
        rtc_ctime.tm_isdst = 0;  // Daylight saving flag
        ret = max31341_set_time(&max31341, &rtc_ctime);
        if (ret)
        {
                printk("failed to set max31341\n");
                return -1;
        }
        ret = max31341_configure_intb_clkout_pin(&max31341, CONFIGURE_PIN_AS_CLKOUT);
        if (ret)
        {
                printk("config intb clkout pin error\n");
                return -1;
        }
        ret = max31341_set_alarm(&max31341, &rtc_ctime, ALARM_PERIOD_EVERYSECOND, ALARM1);
        if (ret)
        {
                printk("setting alarm problem\n");
                return -1;
        }
        ret = max31341_irq_enable(&max31341, ALARM1);
        if (ret)
        {
                printk("failed to set intr\n");
                return -1;
        }
        max31341_irq_clear_flag(&max31341, ALARM1);
        get_alarm(&max31341, ALARM1, &rtc_ctime, ALARM_PERIOD_EVERYSECOND);
        gpio_init_callback(&button_cb_data, button_pressed, BIT(button.pin));
        gpio_add_callback(button.port, &button_cb_data);
        reg_status_t g_stat;
        while (1)
        {
                if(dataReady){
                        max31341_get_time(&max31341, &rtc_ctime);
                        dataReady=0;
                }
                k_msleep(1000);
                
        }
}

and this my overlay file.

&i2c0 {
    status = "okay";
    clock-frequency = <I2C_BITRATE_STANDARD>;
    pinctrl-0 = <&i2c0_default>;
    max31341: max31341@69 {
        compatible = "i2c-device";

        reg = <0x69>;
    };
};
&pinctrl {
    i2c0_default: i2c0_default {
        group1 {
            psels = <NRF_PSEL(TWIM_SDA, 0, 26)>,
                    <NRF_PSEL(TWIM_SCL, 0, 27)>;
            bias-disable;

        };
    };

};



/ {
    buttons {
        compatible = "gpio-keys";
        button5: button_5 {
            gpios = <&gpio0 4 (GPIO_PULL_UP | GPIO_ACTIVE_LOW)>;

        };

    };
    aliases{
        sw5=&button5;
    };

};

[AHaug]

Hi,

To familiarize yourself with creating your own devices and setting them up we recommend that you go through https://academy.nordicsemi.com/courses/nrf-connect-sdk-fundamentals/ and https://academy.nordicsemi.com/courses/nrf-connect-sdk-intermediate/ thoroughly in detail. 

In addition you may get help from the producers of the peripherals you're using w.r.t setting them properly up. I recommend that you consult with the sensors from the datasheet of the max31341 sensor, have a look at the other sensors using max-device as well as inspect the zephyr forums on Discord if any other developers have used this device.

Kind regards,
Andras