// https://datasheets.maximintegrated.com/en/ds/DS3231.pdf #include "wokwi-api.h" #include #include //#include #define DEBUG #ifdef DEBUG #define TRACE_REGISTERS #define TRACE_CONTROL_REGISTER #define TRACE_INVALID_REGISTERS #define TRACE_I2C_CONNECT #define TRACE_I2C_READ #define TRACE_I2C_WRITE #define TRACE_I2C_DISCONNECT #endif /* DEFINE_PIN(VCC); DEFINE_PIN(GND); DEFINE_PIN(SCL); DEFINE_PIN(SDA); DEFINE_PIN(INT_SQW); DEFINE_PIN(RST); DEFINE_PIN(32kHz); */ enum { SECONDS, MINUTES, HOURS, DAY, DATE, MONTH, YEAR, ALARM1_SECONDS, ALARM1_MINUTES, ALARM1_HOURS, ALARM1_DAY_DATE, ALARM2_MINUTES, ALARM2_HOURS, ALARM2_DAY_DATE, CONTROL, STATUS, AGING, TEMPERATURE_MSB, TEMPERATURE_LSB, REGISTERS_COUNT }; // CONTROL enum { A1IE, A2IE, INTCN, RS1, RS2, CONV, BBSQW, EOSC, }; // STATUS enum { A1F, A2F, BSY, EN32KHZ, OSF = 7, }; typedef struct { uint8_t registers[REGISTERS_COUNT]; timer_t oscillator_timer_id; bool got_register_address; uint8_t register_address; bool oscillator_enabled; uint16_t oscillator_counter; uint16_t year; uint8_t month; uint8_t day; uint8_t hours; uint8_t minutes; uint8_t seconds; // uint8_t id; // pin_t pin_reset; // pin_t pin_int; // pin_t pin_32kHz; // bool pin_int_state; //bool pin_32kHz_state; //bool oscillator_output_enabled; //uint16_t oscillator_frequency; //uint64_t oscillator_timer_period; //bool squarewave_output_enabled; //uint8_t squarewave_frequency; } chip_t; //#define bitRead(value, bit) (((value) >> (bit)) & 0x01) //#define bitSet(value, bit) ((value) |= (1UL << (bit))) //#define bitClear(value, bit) ((value) &= ~(1UL << (bit))) //#define bitWrite(value, bit, bitvalue) (bitvalue ? bitSet(value, bit) : bitClear(value, bit)) //#define bit(b) (1 << (b)) static void print_bits(uint32_t num, uint8_t size) { while (size) putchar(((num >> --size) & 1) + '0'); } static uint8_t dec2bcd(uint8_t value) { return value + 6 * (value / 10); } static uint8_t bcd2dec(uint8_t value) { return value - 6 * (value >> 4); } static void set_register(chip_t * const chip, const uint8_t reg, const uint8_t val) { /*if (reg >= REGISTERS_COUNT) { #ifdef TRACE_INVALID_REGISTERS print_start(chip); printf("invalid register 0x%X", reg); print_end(); #endif return; }*/ //chip->registers[reg] = val; switch (reg) { case CONTROL : { chip->registers[CONTROL] = val; // chip->squarewave_output_enabled = !((val >> INTCN) & 0b1); //chip->squarewave_frequency = (val >> RS1) & 0b11; // #ifdef TRACE_CONTROL_REGISTER //static const uint16_t squarewave_frequencies[] = {1, 1024, 4096, 8192}; ////print_start(chip); //printf("control=0b"); //print_bits(chip->registers[CONTROL], 8); //printf("\nsqw=%s\n", chip->squarewave_output_enabled == true ? "true" : "false"); //printf("sqwfreq=0b"); //print_bits(chip->squarewave_frequency, 2); //printf(" -> %u Hz\n", squarewave_frequencies[ chip->squarewave_frequency ]); //#endif break; } case STATUS : { // disallow A1F and A2F to be set to 1 chip->registers[STATUS] = (chip->registers[STATUS] & val) | (val & ~((1 << A1F) | (1 << A2F))); //chip->oscillator_output_enabled = (val >> EN32KHZ) & 0b1; //if (chip->oscillator_output_enabled == false) { // // DS3232 pin_write(chip->pin_32kHz, LOW); // pin_mode(chip->pin_32kHz, INPUT); // } else { // pin_mode(chip->pin_32kHz, OUTPUT); //} //#ifdef TRACE_CONTROL_REGISTER // //print_start(chip); //printf("status=0b"); //print_bits(chip->registers[STATUS], 8); //printf("\nosc=%s\n", chip->oscillator_output_enabled == true ? "true" : "false"); // #endif break; } case SECONDS: chip->seconds = val % 60; chip->registers[SECONDS] = dec2bcd(chip->seconds); break; case MINUTES: chip->minutes = val % 60; chip->registers[MINUTES] = dec2bcd(chip->minutes); break; case HOURS: chip->hours = val % 24; chip->registers[HOURS] = dec2bcd(chip->hours) & 0x3F; break; case DAY: chip->registers[DAY] = val & 7; break; case DATE: chip->day = val % 31; chip->registers[DAY] = dec2bcd(chip->day) & 0x3F; break; case MONTH: chip->month = val % 2; chip->registers[MONTH] = dec2bcd(chip->month) & 0x3F; break; case YEAR: chip->year = val; chip->registers[YEAR] = dec2bcd(chip->year); break; default : { #ifdef TRACE_INVALID_REGISTERS //print_start(chip); printf("invalid register 0x%X\n", reg); #endif break; } } } bool i2c_connect(void * const user_ctx, const uint32_t address, const bool direction) { chip_t *chip = user_ctx; chip->got_register_address = false; //#ifdef TRACE_I2C_CONNECT // printf("i2c_connect: addr:0x%X, %s\n", address, direction == true ? "read" : "write"); // #endif return true; } uint8_t i2c_read(void * const user_ctx) { chip_t * const chip = user_ctx; const uint8_t data = chip->registers[ chip->register_address ]; #ifdef TRACE_I2C_READ printf("i2c_read: reg:%hhu, 0b", chip->register_address); print_bits(data, 8); printf("\n"); #endif if (++chip->register_address == REGISTERS_COUNT) { chip->register_address = 0; } return data; } bool i2c_write(void * const user_ctx, const uint8_t data) { chip_t * const chip = user_ctx; if (!chip->got_register_address) { chip->got_register_address = true; chip->register_address = data; #ifdef TRACE_I2C_WRITE printf("i2c_write reg:%hhu\n", data); #endif } else { #ifdef TRACE_I2C_WRITE printf("i2c_write: reg:%hhu, 0b", chip->register_address); print_bits(data, 8); printf("\n"); #endif set_register(chip, chip->register_address, data); if (++chip->register_address == REGISTERS_COUNT) chip->register_address = 0; } return true; } void i2c_disconnect(void * const user_ctx) { chip_t * const chip = user_ctx; #ifdef TRACE_I2C_DISCONNECT printf("i2c_disconnect\n"); #endif } void updateTimeRegisters(chip_t * const chip) { chip->seconds++; if (chip->seconds == 60) { chip->seconds = 0; chip->minutes++; if (chip->minutes == 60) { chip->minutes = 0; chip->hours++; if (chip->hours == 24) { chip->hours=0; } } } printf("%02d:%02d:%02d\n", chip->hours, chip->minutes, chip->seconds); } void chip_oscillator(void * const user_data) { //, const uint32_t timer_id) { chip_t * const chip = (chip_t * const)user_data; if (chip->oscillator_enabled == true) { //&& timer_id == chip->oscillator_timer_id) // restart the timer //chip->oscillator_frequency = 32768; //chip->oscillator_timer_period = 1000000000 / 2 / 32768; timer_start_ns(chip->oscillator_timer_id, 1000000000 / 2 / 32768, false); // if the oscillator just started, and then every seconds (when the counter overflows) if (chip->oscillator_counter == 0) { // update the timekeeping registers updateTimeRegisters(chip); } // // if the 32kHz output is enabled // if (chip->oscillator_output_enabled == true) { //// invert the state of the 32kHz pin // pin_write(chip->pin_32kHz, chip->pin_32kHz_state == true ? HIGH : LOW); // chip->pin_32kHz_state = !chip->pin_32kHz_state; // } // // if the squarewave output is enabled // if (chip->squarewave_output_enabled == true) { // static const uint8_t oscillator_dividers[] = { 15, 5, 3, 2 }; // // if it's time to invert the state of the INT/SQW pin // if (chip->pin_int_state == ((chip->oscillator_counter >> oscillator_dividers[ chip->squarewave_frequency ]) & 1)) { // // invert the state of the INT/SQW pin // pin_write(chip->pin_int, chip->pin_int_state == true ? HIGH : LOW); // chip->pin_int_state = !chip->pin_int_state; // } // } // increase the counter ++chip->oscillator_counter; } } void pin_watch_callback(void *user_data, pin_t pin, uint32_t value) { chip_t * const chip = (chip_t * const) user_data; printf("pin %d changed to %d\n", pin, value); } void chip_init() { setvbuf(stdout, NULL, _IOLBF, 1024); chip_t * const chip = calloc(1, sizeof(chip_t)); //static uint8_t chips_counter = 0; //chip->id = chips_counter++; const i2c_config_t i2c_config = { .user_data = chip, .address = 0b1101000, .scl = pin_init("SCL", INPUT), .sda = pin_init("SDA", INPUT), .connect = i2c_connect, .read = i2c_read, .write = i2c_write, .disconnect = i2c_disconnect, }; const timer_config_t chip_oscillator_timer_config = { .user_data = chip, .callback = chip_oscillator, }; const pin_watch_config_t pin_watch_config = { .user_data = chip, .edge = BOTH, .pin_change = pin_watch_callback, }; i2c_init(&i2c_config); //chip->pin_int = pin_init("INT_SQW", OUTPUT); //chip->pin_reset = pin_init("RST", INPUT); //pin_watch(chip->pin_reset, &pin_watch_config); //chip->pin_32kHz = pin_init("32kHz", OUTPUT); //chip->pin_32kHz_state = false; //chip->counter = 0; //chip->register_address = UINT8_MAX; //chip->registers[CONTROL] = 0b00011100; //chip->registers[STATUS] = 0b10001000; //set_register(chip, CONTROL, 0b00011100); //set_register(chip, STATUS, 0b10001000); //set_register(chip, STATUS, 0b10101011); //chip->squarewave_output_enabled = !((chip->registers[CONTROL] >> INTCN) & 0b1); //chip->squarewave_frequency = (chip->registers[CONTROL] >> RS1) & 0b11; chip->oscillator_enabled = true; //chip->oscillator_output_enabled = (chip->registers[STATUS] >> EN32KHZ) & 0b1; //chip->oscillator_frequency = 32768; //chip->oscillator_timer_period = 1000000000 / 2 / chip->oscillator_frequency; chip->oscillator_counter = 0; chip->oscillator_timer_id = timer_init(&chip_oscillator_timer_config); timer_start_ns(chip->oscillator_timer_id, 0, false); uint32_t rawtime = time(0); printf("initialized\n"); }