The 80’s were simpler times, and life at that point was easy, and things worked well.. But then came the 90’s and along came Windows! I vaguely remember the 100’s of lines of weird C++ code, calling this API, then that API, just to get a window on the screen with “Hello world”, it all made zero sense at the time, not just to me, but a lot of our more traditional programmers, and I knew from that point on things had changed big time for me; I would no longer be a part of that world, I never wanted to see it ever again, and (for me at least) Windows/C++ had tainted the simplicity of C.

I guess this epiphany happened to a lot of other people too, as dozens of new programming languages, development environments, and operating systems, all sprung up around this time, each preaching a better and easier life than C/C++. My department however had committed to Windows, and we were all electronics engineers, so it was Visual Basic, then Delphi which won us over. Both languages hid the (high) complexity of Windows behind a simple event driven point and click interface, great for us engineers who simply wanted to get something done.

Someone coming into programming in 2026 will likely be offered JavaScript or Python as their first development language, both require an OS, an IDE, an interpreter or a browser, and probably the equivalent of a 1980’s supercomputer just to print “Hello World”. No beginner is really going to have a clue how their Print “Hello World” got onto their screen, because doing so requires understanding a API stack a mile high; If this was where I had to start my programming journey, I might never have begun, as I like to understand how things work. To many, I expect the inner workings of the stack between their chosen programming language, and the work their program actually does, is still black-magic.

I was lucky to have peeked behind the curtains early in my career, and have an intimate knowledge of CPU architectures, but even I have basically given up trying to understand the layers or stack. I read and write to whatever API is exposed, and hope the level below me knows what it is doing! Occasionally I have written parts of ‘the stack’, building hardware and writing a driver for Windows or Linux to support it, but even then I am conforming to a set of norms for the level above it, and I doubt anybody ever checked my code.

Only with Micro-controller projects am I fully back in control, and with them (for me at least) there generally was no stack; My program was the stack! This was however back with older 8-bit or 16-bit micros, and micro-controllers were not immune from technologies progress. Today’s micro-processors are amazing pieces of technology that have improved in leaps and bounds, going to multi-core monsters, with layers of complexity and peripherals that would shame a 1980’s super-computers. Unlike software though, they have done this while improving there efficiency and lowering there cost. For me, the best thing about all of this is you don’t really have to use any of this new complexity, and a simple blinking LED can still be done in a few primitive lines of C.

From a blinking LED I can add in all the complexity, and use as many of these new peripherals as I like. This is exactly like I did back in 1980 with my first Z80 chip, no real need for a stack or an API.

But API’s and stacks get added anyway, for convenience, reliability and speed of development. Abstracting away complex code behind a set of C SDK libraries, an RTOS, MicroPython, Arduino or even MMBasic, is a way of not having to learn the 1000’s of pages of CPU and peripheral datasheets. A lot of people are happy to take these easier options, including me, but lets not kid ourselves that we diligently read the libraries of source code that get compiled into our binaries, most of the time we are generally trusting the coders have done a good job.

A modern micro-processor, or System-On-Chip (SOC), is a far different beast from a micro-controller, adding many more layers of complexity, security, memory management, cores and peripherals, such as PCIe, USB3, Ethernet, or even a GPU. They are so complex that they often require there own bootstrap program to even initialise everything before it even finds and runs even a single line of your code. Very few programmers are brave enough to work bare-metal at this level because often as not these SOC’s, unlike micro-controllers, hide or abstract everything behind NDA’s or binary API’s, this is why for example on your cell phone, real world people accept they are going to work through an operating system and use the provided API’s.

So, to segue again back to my first paragraph, if I was being honest with my real goals, I love the fact that when working with micro-controllers I am effectively going back to a simpler time, a time where I owned, and understood the stack, where the stack hardly ever changed, and when I turned my computer on I was running my program code within microseconds. I guess that is why there is a resurgence in retro-computing going on, people still want to know what is behind the curtains and understand how it all works!

I am one of those people, but I will never go back to using a retro-computer or retro-operating system for my daily drive, I am happy the stack is there and hundreds of thousands of people have stood on each others shoulders, to bring me the marvelous Linux and IOS GUI’s I have today. However there is a cost, and that cost is complexity, efficiency, and the fact that programmers (like me) take all these layers of code for granted without looking behind the curtain. A whole Eco-system based on the trust that somebody else has done your due diligence for you!

This is especially scary once you realise how many bad actors are out there, examining every line of these stacks for code vulnerabilities. This is happening every hour of the day, and they are finding them with ease. AI, over-complicated programming styles, and dependency hell, are making it harder for the developers to miss these cracks in their code reviews, and easier for the bad guys to find them.

Hacker News Link and Comments For Story Above

Unfortunately, as always, it is up to you to balance the security, against the ease and convenience, or, like the vast majority of us, believe the myth that your system is secure and does not have these problems.

Thanks to Gemini for the memes, but like AI vibe-coding it pays to look at the finer details

The vulnerabilities of these programming stacks were one of the plot elements in my free sci-fi trilogy eBook The Summer Of Reasoning. I still think I did a good job in that book of explaining the problem, why it matters, and the consequences of when it fails.

These big fails get all the attention of course, but I am sure that for each big fail, there are dozens of others simply swept under the rug. I can write this as I am almost at the end of my career, have seen many of these failures first hand, and I don’t have any particular agenda as I am no longer actively looking for major projects (though small gigs are still appreciated). I have also seen many successful projects, though mostly in terms of delivery rather than cost!

Tell me what you need, AND I will tell you how to get along without it. – Scott Adams

As a developer who specialises in writing systems for people who generally haven’t really got a clue what they want, I can usually tell the moment I walk in the room with them that they are either under or over-thinking the scope or complexity of their project. Yes, them not knowing exactly what they want makes life a bit harder for me, (though sometimes easier,) but what it doesn’t do and should never do, is give me the right to screw them over, or pretend I can do something when I cannot.

So lets get some truisms out of the way. Firstly, your BIG system is probably not really that big. Wow it stores a billion records, or wow it has to support five hundred users. Let me tell you something, there are very few database servers that don’t give you this out-of-the-box, and the two biggest of these (Postgres and MySQL) are completely licence-free. Furthermore it is a pretty shitty system-level programmer in 2025 who does not know the protocols to support multiple users.

Secondly your COMPLEX system is likely not even that complex. Small, or even lone developers like me have written many ERP, MRP or whatever the current buzz-word system it is. We are generally NOT re-inventing the wheel but re-using well proven techniques with some customisation and business logic added, so unless you are totally replacing everything, your system is unlikely to be this complex. With the advent of AI this is even more truer now than it was in the past.

But, you say, it also needs to be up 99.99% of the time, 24×7. Well welcome to modern IT, you can run hundreds of sessions easily on a low end local server, and you don’t need to go to AWS or whatever cloud-de-jour your consultant says it must be on. Remember, a cloud is just a server that you have no clue where it is physically located, and especially if you are a small player, you generally have no clue who to contact if there is a problem. Backups, fallback servers, docker containers, clusters are all well proven techniques that people like me and most small IT shops can install and configure with ease.

But people like me will never tender for your BIG project. For while I, and many other small businesses like me, have a perfect track record of delivering BIG systems for customers, (and there a a shed-load of developers far better than me); We are everything you seem to hate, so lets get them into the open shall we:

Firstly I am a one man shop, a lone developer. Yes I could easily obfuscate all this behind my web site; and on web sites I often see the third-person to talk about companies, where phrases like “we can do this” and “we specialise in that” hide the fact they have one or two developers behind layers of non-relevant management, sales and consultancy. I even do the same on my website, but I always make it very clear there is only me, and it will be only me who will help specify, write, install and support your system. Good luck having that person on speed-dial if you use a big company. If in doubt ask the question directly, but do not dismiss them because of it as even the biggest project probably relies on one or two key developers.

Secondly, I am not going to fill out your 50 page tender document, which is probably mostly technically wrong and full of corporate speak that has no relevance whatsoever to the project you want me to do. As an individual I do not have the time for this, nor can I work with your liability clauses, nor do I have a company statement on my carbon neutrality, anti-slavery, how I am inclusive, or anything like that; You should start out trusting track-proven vendors meet the criteria, unless they give you a genuine reason not too.

Then there is the technology that everyone seems so keen on specifying these days. This is despite the fact that it does nothing but exclude people who use much more mature technologies, and are likely to get the project done on time and budget. A lot of this is because your IT Manager or CTO heard about some new trend at their last “technical conference”, or they have paid an over-priced consultant to specify their new system, and to justify the extravagant cost they have hit all the buzz-words, or worse, have specified it so their own company or partner will be the only choice you will have to develop it. If the development tools and systems used are supported and you own all the code to the final system there is no real reason to reject something.

Lastly, it is highly likely that by the time a big company has written a line of code, I, or someone like me, will have a prototype ready. This is not hubris, it is just the way I operate, in order to get an alpha-stage product in front of a customer quickly, as I know they have likely gotten something wrong, and they will see it quicker with something in front of them.

Of course, I am not going to tender for replacing your big system, nor am I going to tender for our next government tax or social security system, but do not think for one minute it is because me, or another small business or developer like me cannot do it. Your system is NOT hard, it is you and your procurement procedures that are generally making it hard for small companies to help you, and it is you and your procurement systems and attitude that will likely make the project fail, be delayed or go over-budget.

None of this is to say do not do your due diligence, just make sure you due diligence does not exclude us small players.

(Dilbert.com)

So I thought I would design and build a clock, one which will reliably keep the time and be pretty well maintenance free for its hopefully long and boring life. But why would anybody need to design a clock today, surely every variation has been tried? Well, for one thing, this clock is going to be pretty big. Although it is only a seven-segment display, with two digits for hours and two for minutes, each segment is going to be a wine bottle. So 7 bottles are required per digit, in total 28 bottles.

Inside each bottle will be an LED strip or similar so we can light the segment, therefore we need a circuit board that can drive 28 LED strips, also, to make the flashing colons that separate the hours and minutes, the ends of two bottles will be used, and so another output is required to drive the LED’s in those. That’s 29 drivers, 29 bottles, 2M x 1M in size minimum, and as a total package with some form of mounting, quite heavy I guess!

The boring electronics prototype

The electronics for this were always going to be easy. Again it’s a project I would normally slap in an old PIC microcontroller and an RTC and have it designed in a few hours. But that was the old 1990’s Boz, the new 2025 Boz is on a mission to try out some of the new technologies out there, and the modern micro-controller for today will be (rolls-the-dice..) the ESP32-C3. Specifically the ESP32-C3-WROOM-02 a RISC-V 32-bit processor with Wi-Fi, Bluetooth, 400KB of RAM and 2MB of Flash all for $3.30. (A bit over-kill for a clock, but welcome to 2025!)

So a brand-new processor I have never used before, or even seen before a few days ago should be exciting, or at least a bit risky? Maybe, maybe-not. Lets go on a journey together. For this journey, the AI of choice will be Googles Gemini 2.0, a competent, if pretty boring and sensible AI, so while Grok 3 may be considered your rebellious genius teenager, Gemini 2.0 is probably your quiet old uncle, the retired school teacher who lives in his shed and doesn’t really talk to many people, but also tends to be sensible.

The Schematic.

Yes, pretty boring and certainly not rocket science. An RTC, a serial input for a GPS (Not yet sure if I can get a signal where it is going to be located, but a good time-source never-the-less), and 29 open-collector outputs that can drive a few hundred milliamps at up to 24V, total BOM cost around $8 from LCSC

Firstly, it is obvious that a lot of the big AI models have a good understanding of electronics, and simple questions, like how much power will this or that draw? or what are the maximum and minimum supply voltages for power and IO? are generally answered correctly. However, that accuracy is about 90% at best and 10% of answers will be confidently answered wrongly, with a quick and humble apology when the mistake is finally pointed out. Again the ability to feed a schematic into a AI would be fantastic, but we are not there yet. (or if we are I haven’t seen it!)

Asking questions like, what capacitance would I require on VCC1 to keep the RTC running for 8-hours in the configuration shown was answered quite well with suitable workings out shown and the real-life circuit performing slightly better than the calculation

There are a few grey areas out there which may lead to said AI’s not being too accurate, for example, if I decided to use the USB interface that the ESP32-C3 has for program/debug, would I still require the boot button to program it? The reference design does show almost every possible IO pin used for programming and makes you wonder if there would be any left afterwards. People building these boards on the internet tend to favour the serial port and use of the DTR and RTS of a serial to USB driver to program it, well I’m telling you now, two wires to a USB connector are all you need and you do not need to press the boot or reset switches ever. Also as I used my usual GPIO expansion technique for slowly changing output ports by using a series of shift registers so that was never an issue..

Programming.

This is where it got interesting. After bigging up the project to Gemini (it felt right to do so!), I told it I was using the Arduino IDE (as the VSCode extension for the ESP32 was, to say it politely, work in progress!), I got it all excited to help me. I then fed the following prompt into him/her/it..

The ESP32-C3 is on a ESP32-C3-WROOM-02 board

The connections from the ESP32-C3 to the DS1302 are:

I/O (Pin 6 of DS1302) to GPIO 0
CE (Pin 5 of DS1302)  to GPIO 1
SCLK (Pin 7 of DS1302) to GPIO 3

The clock will output its time in the format HH:MM to a seven-segment display. It does this by sending 32 bytes of (7 segment) data out to four 74HC595 shift registers in series, the first shift register is hours x 10, the second shift register is hours x 1, the third shift register is minutes x 10, the last shift register is minutes x 1, The connections from the ESP32-C3 to the shift registers are as follows:

74HC595 pin 14 (DS) of first shift register to GPIO 6
74HC595 pin 12 (STCP) of all shift registers to GPIO 7
74HC595 pin 11 (SHCP) of all shift registers to GPIO 5

The 7-segments are connected to each 74HC595 as follows

Q0 = segment a
Q1 = segment b
Q2 = segment c
Q4 = segment d
Q5 = segment e
Q6 = segment f
Q7 = segment g

I want to be able to connect to the ESP32 Wi-Fi and set the time on the DS1302 through a web page, then update the LED outputs of to the shift register every time it changes

I would like to understand the code I am writing by not using any libraries where possible e.g. the DS1302 communication should be easy without libraries, though the Wi-Fi stuff might be a bit hard for me to understand.

Is this enough to go on?

I literally downloaded the Arduino IDE, downloaded the ESP32 extension for it, copied the code it generated from the above prompt in and bugger me if it didn’t just work!

Well, almost! It did kind of work, the clock counted and showed the time, the web-page worked and set the time, but of course the devil is always in the detail, the web-page was bloated and overkill and pretty ugly, it also only set the time, not the day and date, which I would require latter for daylight-savings calculations. Also as I lay there thinking about it, I thought, why would I want to type in the time from a web-page when I had a phone that already had the correct date and time down to the microsecond? I quickly corrected my prompt, asked it to separate out the networking part, into another module, change the Wi-Fi client into a Wi-Fi access point, made the web page into a simple button and bit of java-script to send the time/date, and manually tidied up the landing page a bit (All using AI prompts of course as I am really totally shit at this web stuff!)

As a side rant, lets talk again about that bloat! 400KB Ram and 2MB ROM and 75% used. I wont even try to understand the reasoning behind the colossal use of resources, lets just say we are in 2025 and the future seems to be bloat! Seriously, nobody these days seems to give a rats-arse about throwing in libraries that go into thousands of lines of code they have no idea what any of it does. Sure it makes my life easier, but extrapolating the extra computation and resources required by computers these days the waste of power must be several power stations! Anyway, rant over, back to the project..

The Arduino IDE itself is pretty bullet-proof; as I remember it from about 10 years earlier simply selecting the ESP32C3 dev module as my board, and setting the “USB CDC on Boot” to get debug information was all that was required, all refreshingly easy.

OK, so by now you have noticed the lack of pictures of the actual epic bottle-hardware! well, this is only the first part of the post as I still have to mount those 28.5 wine bottles (the point five being the two bottle-ends for the colon) on a very large mount, shove the LED’s in them, and get a 24V power supply as everything so far has been with USB power and logic probes. A few friends have offered to help in this part as my artistic flair is about as shitty as my web skills!

The code to the working board so far is below. It may change but as it stands it works as a stand-alone clock (just add big LED’s!)..

To be continued..

IndevinClock.ino

// Colabaration between Boz and various AI's that provides the logic to 
// manage the DS1302 real-time clock and update the display through the
// shift register GPIO expander. And provide a web portal to set the time.
// Full Hardware design is/will be at rodyne.com
// All Designs relating to this project are Public Domain.

#include <Arduino.h>
#include "networking.h"

// Pin Definitions
#define DS1302_CE_PIN 1  // Chip Enable
#define DS1302_IO_PIN 0  // Data I/O
#define DS1302_SCLK_PIN 3 // Serial Clock
#define SHCP_PIN 5  // 74HC595 Shift Register Clock (SHCP)
#define DS_PIN 6    // 74HC595 Data Input (DS)
#define STCP_PIN 7  // 74HC595 Storage Register Clock (STCP)
#define COLON_PIN 10  // flashing colon output
#define DSTLED_PIN 4  // debug led

const char * DayOfWeek[] =  { "ERR!","Mon","Tue","Wed","Thu","Fri","Sat","Sun" };

const uint8_t Lookup7seg[] = { 0b00111111, 0b00000110, 0b01011011, 0b01001111, 0b01100110, 0b01101101, 0b01111101, 0b00000111, 0b01111111, 0b01101111 };

uint8_t RTCsec, RTCmin, RTChour, RTCday, RTCmonth, RTCyear, RTCdow, Colon; // global variables visible to networking module
uint8_t LastUpdate, LastMinVal; // local to this unit


// Function Prototypes
void ds1302_write(uint8_t address, uint8_t data);
uint8_t ds1302_read(uint8_t address);
void ds1302_setTime(uint8_t sec, uint8_t min, uint8_t hour, uint8_t day, uint8_t month, uint8_t year, uint8_t dow);
void ds1302_getTime();
uint8_t bcdToDec(uint8_t val);
uint8_t decToBcd(uint8_t val);
void displayTime(); 
bool isDaylightSavings();

bool isDaylightSavings() 
{
  // New Zealand Daylight Saving Time (DST) rules: Starts: 2:00 a.m. on the last Sunday in September. Ends: 3:00 a.m. on the first Sunday in April.

  if (RTCmonth < 4 || RTCmonth > 9) 
  {
    return (RTCmonth > 9); // DST is active from October to March
  } 
  else if (RTCmonth == 4) 
  {
    // Check if it's the first Sunday in April
    int firstSunday = 8 - RTCdow; // Calculate the date of the first Sunday
    if (RTCday < firstSunday) 
    {
      return true; // DST is still active before the first Sunday
    } 
    else if (RTCday == firstSunday) 
    {
      return (RTChour < 3); // DST ends at 3:00 a.m.
    } 
    else 
    {
      return false; // DST is not active after the first Sunday
    }
  } 
  else if (RTCmonth == 9) 
  {
    // Check if it's the last Sunday in September
    int lastSunday = 30 - ((RTCdow + (30 - RTCday)) % 7); // Calculate the date of the last Sunday
    if (RTCday > lastSunday) 
    {
      return true; // DST is active after the last Sunday
    } 
    else if (RTCday == lastSunday) 
    {
      return (RTChour >= 2); // DST starts at 2:00 a.m.
    } 
    else 
    {
      return false; // DST is not active before the last Sunday
    }
  }
  return false; // Should not reach here
}

void displayTime() 
{
  uint32_t displayData = 0;
  uint8_t  rawHour = RTChour;

  if(isDaylightSavings()) // convert hrs to DST for display
  {
    if(rawHour==0)
      rawHour=23;
    else
      rawHour--;
  }

  Serial.print(DayOfWeek[RTCdow]); Serial.print(" ");
  Serial.print(rawHour); Serial.print(":");
  Serial.print(RTCmin); Serial.print(" ");
  Serial.print(RTCday); Serial.print("/");
  Serial.print(RTCmonth); Serial.print("/");
  Serial.print(RTCyear);
  if(isDaylightSavings()) // convert hrs to DST for display
    Serial.println(" (Daylight Savings Active)");
  else
    Serial.println("");


  uint8_t hoursTens = rawHour / 10;
  uint8_t hoursOnes = rawHour % 10;
  uint8_t minutesTens = RTCmin / 10;
  uint8_t minutesOnes = RTCmin % 10;

  // Combine digit data into a 32-bit value
  displayData |= (uint32_t)Lookup7seg[minutesOnes];
  displayData <<= 8;
  displayData |= (uint32_t)Lookup7seg[minutesTens];
  displayData <<= 8;
  displayData |= (uint32_t)Lookup7seg[hoursOnes];
  displayData <<= 8;
  displayData |= (uint32_t)Lookup7seg[hoursTens];

  // clock out data to shift registers
  for (int i = 31; i >= 0; i--) 
  {
    digitalWrite(DS_PIN, (displayData >> i) & 1);
    digitalWrite(SHCP_PIN, HIGH);
    digitalWrite(SHCP_PIN, LOW);
    delay(1);
  }

  // Latch data to outputs
  digitalWrite(STCP_PIN, HIGH);
  digitalWrite(STCP_PIN, LOW);
}

void ds1302_write(uint8_t address, uint8_t data) 
{
  digitalWrite(DS1302_CE_PIN, HIGH);
  shiftOut(DS1302_IO_PIN, DS1302_SCLK_PIN, LSBFIRST, address);
  shiftOut(DS1302_IO_PIN, DS1302_SCLK_PIN, LSBFIRST, data);
  digitalWrite(DS1302_CE_PIN, LOW);
}

uint8_t bcdToDec(uint8_t val) 
{
  return (val / 16 * 10) + (val % 16);
}

uint8_t decToBcd(uint8_t val) 
{
  return (val / 10 * 16) + (val % 10);
}

uint8_t ds1302_read(uint8_t address) 
{
  uint8_t data;
  digitalWrite(DS1302_CE_PIN, HIGH);
  shiftOut(DS1302_IO_PIN, DS1302_SCLK_PIN, LSBFIRST, address);
  pinMode(DS1302_IO_PIN, INPUT);
  data = shiftIn(DS1302_IO_PIN, DS1302_SCLK_PIN, LSBFIRST);
  pinMode(DS1302_IO_PIN, OUTPUT);
  digitalWrite(DS1302_CE_PIN, LOW);
  return data;
}

void ds1302_getTime() 
{
  ds1302_write(0x8F, 0x00); // Dummy write to DS1302 to prepare for read
  RTCsec = bcdToDec(ds1302_read(0x81) & 0x7F);
  RTCmin = bcdToDec(ds1302_read(0x83));
  RTChour = bcdToDec(ds1302_read(0x85));
  RTCday = bcdToDec(ds1302_read(0x87));
  RTCmonth = bcdToDec(ds1302_read(0x89));
  RTCdow = bcdToDec(ds1302_read(0x8b));
  RTCyear = bcdToDec(ds1302_read(0x8D));
}

void ds1302_setTime(uint8_t sec, uint8_t min, uint8_t hour, uint8_t day, uint8_t month, uint8_t year, uint8_t dow) 
{
  // no checks on data written!
  ds1302_write(0x8E, 0x00); // Disable DS1302 write protect
  ds1302_write(0x80, decToBcd(sec));   // 0..59
  ds1302_write(0x82, decToBcd(min));   // 0..59
  ds1302_write(0x84, decToBcd(hour));  // 0..23
  ds1302_write(0x86, decToBcd(day));   // 1..31
  ds1302_write(0x88, decToBcd(month)); // 1..12 
  ds1302_write(0x8A, decToBcd(dow));   // 1..7
  ds1302_write(0x8C, decToBcd(year));  // 0..99
  ds1302_write(0x8E, 0x80); // Re-enable DS1302 write protect
  ds1302_getTime();
  Serial.print(" Set Time ");
  Serial.print(RTChour); Serial.print(":");
  Serial.print(RTCmin); Serial.print(":");
  Serial.print(RTCsec); Serial.print(" - ");
  Serial.print(DayOfWeek[RTCdow]); Serial.print(" ");
  Serial.print(RTCday); Serial.print("/");
  Serial.print(RTCmonth); Serial.print("/20");
  Serial.print(RTCyear);
  if(isDaylightSavings()) // convert hrs to DST for display
    Serial.println(" (Daylight Savings Time is Active)");
  else
    Serial.println("");
}

void setup() 
{
  Serial.begin(115200); // Remember to set IDE "USB CDC ON BOOT" to ENABLED or serial WONT work!

  // INIT DS1302
  pinMode(DS1302_CE_PIN, OUTPUT);
  pinMode(DS1302_IO_PIN, OUTPUT);
  pinMode(DS1302_SCLK_PIN, OUTPUT);
  digitalWrite(DS1302_CE_PIN, HIGH);
  digitalWrite(DS1302_SCLK_PIN, LOW);

  // check clock is running and if not set it running and with a default time/date
  ds1302_write(0x8F, 0x00); // Dummy write to prepare for read
  uint8_t RTCDisabled = ds1302_read(0x81) & 0x80;
  if(RTCDisabled)
  {
    // default time
    ds1302_setTime(0, 0, 8, 1, 4, 25, 2);
  }

  // INIT shift reg
  pinMode(SHCP_PIN, OUTPUT);
  pinMode(DS_PIN, OUTPUT);
  pinMode(STCP_PIN, OUTPUT);
  pinMode(COLON_PIN, OUTPUT);
  pinMode(DSTLED_PIN, OUTPUT);
  digitalWrite(SHCP_PIN, LOW);
  digitalWrite(STCP_PIN, LOW);    

  // init WiFi
  initWiFi();

}

void loop() 
{
  ds1302_getTime();

  if(++LastUpdate>10 || LastMinVal!=RTCmin ) // Update time every 10 seconds or if minutes change (so we can see flow-active LED flash)
  {
    LastUpdate=0;
    LastMinVal=RTCmin;
    displayTime();
  }

  // flash colon at 1 sec
  if (Colon==0) Colon=1; else Colon=0;
  digitalWrite(COLON_PIN, Colon);  
  digitalWrite(DSTLED_PIN, Colon);  

  server.handleClient();  // Handle any web client requests

  delay(1000);
}

networking.h

// Colabaration between Boz and various AI's that provides the functionality to 
// connect to and set the clock using a wifi connection and web browser
// All Designs relating to this project are Public Domain.

#ifndef NETWORKING_H
#define NETWORKING_H

#include <WiFi.h>
#include <WebServer.h>

// Access Point settings
extern const char* ap_ssid;
extern const char* ap_password;
extern IPAddress local_ip;
extern IPAddress gateway;
extern IPAddress subnet;

extern uint8_t  RTCsec, RTCmin, RTChour, RTCday, RTCmonth, RTCyear, RTCdow; // global variables

extern void ds1302_setTime(uint8_t sec, uint8_t min, uint8_t hour, uint8_t day, uint8_t month, uint8_t year, uint8_t dow);
extern void displayTime(); 
extern bool isDaylightSavings();

extern WebServer server;

// Function declarations
void initWiFi();
void handleRoot();
void handleSetTime(); 
void handleNotFound();

#endif

networking.cpp

// Colabaration between Boz and various AI's that provides the functionality to 
// connect to and set the clock using a wifi connection and web browser
// All Designs relating to this project are Public Domain.

#include "networking.h"
#include <Arduino.h>

// Access Point settings
const char* ap_ssid = "Bullsi-Clock";
const char* ap_password = "boz"; // actual password not required but add one here if req
IPAddress local_ip(192, 168, 4, 1);
IPAddress gateway(192, 168, 4, 1);
IPAddress subnet(255, 255, 255, 0);

// Create web server on port 80
WebServer server(80);

void handleRoot() // handler for landing page
{
  String html = "<!DOCTYPE html><html><head>";
  html += "<meta name='viewport' content='width=device-width, initial-scale=1'>";
  html += "<style>";
  html += "body { font-family: Arial, sans-serif; text-align: center; margin: 20px; }";
  html += "h1 { color: #0066cc; font-size: 2em;}"; // Larger heading
  html += ".clock { font-size: 3em; margin: 20px 0; }"; // Larger clock
  html += "button {";
  html += "  background-color: #4CAF50;";
  html += "  color: white;";
  html += "  padding: 15px 30px;"; // Larger button
  html += "  border: none;";
  html += "  cursor: pointer;";
  html += "  font-size: 1.2em;"; // Larger font
  html += "}";
  html += "</style>";
  html += "<script>";
  html += "function sendCurrentTime() {";
  html += "  const now = new Date();";
  html += "  const hours = now.getHours();";
  html += "  const minutes = now.getMinutes();";
  html += "  const seconds = now.getSeconds();";
  html += "  const year = now.getFullYear();";
  html += "  const month = now.getMonth() + 1;";
  html += "  const day = now.getDate();";
  html += "  const dow = now.getDay() === 0 ? 7 : now.getDay();";
  html += "  const url = `/settime?hours=${hours}&minutes=${minutes}&seconds=${seconds}&year=${year}&month=${month}&day=${day}&dow=${dow}` ;";
  html += "  fetch(url);";
  html += "}";
  html += "</script>";
  html += "</head><body>";
  html += "<h1>Indevin Bulls-i Clock</h1>";
  // Display current time
  html += "<div class='clock'>";
  html += String(RTChour / 10) + String(RTChour % 10) + ":" + (RTCmin < 10 ? "0" : "") + String(RTCmin);
  html += "</div>";
  html += "<p>This clock was designed and built by Boz, the author of the original Bulls-i program which ran vintages 2008-2025.</p>";
  html += "<p>For more info on this device and what he's up to currently, goto <b>rodyne.com</b> (when you're back on a normal network!)</p>";
  html += "<p><button onclick='sendCurrentTime()'>Set Date/Time from this Phone</button></p>";
  html += "</body></html>";
  server.send(200, "text/html", html);  
}

void handleSetTime() // Handler for the settime URL (linked from the SetupWifi() fn)
{
  if (server.hasArg("hours") && server.hasArg("minutes") && server.hasArg("seconds") && server.hasArg("year") && server.hasArg("month") && server.hasArg("day") && server.hasArg("dow")) 
  {
    RTChour = server.arg("hours").toInt();
    RTCmin = server.arg("minutes").toInt();
    RTCsec = server.arg("seconds").toInt();
    RTCyear = server.arg("year").toInt() - 2000;
    RTCmonth = server.arg("month").toInt();
    RTCday = server.arg("day").toInt();
    RTCdow = server.arg("dow").toInt();
    ds1302_setTime(RTCsec, RTCmin, RTChour, RTCday, RTCmonth, RTCyear, RTCdow); // Include dow
    server.send(200, "text/plain", "Date/Time set successfully");
  } 
  else 
    server.send(400, "text/plain", "Something went wrong. (Probably your shitty phone!)");  
}

// Handler for 404 errors
void handleNotFound() 
{
  // Redirect back to the root page
  server.sendHeader("Location", "/");
  server.send(302, "text/plain", "");
}

void initWiFi() 
{
  // Disconnect from any previous WiFi connections
  WiFi.disconnect();
  // Configure access point with static IP
  WiFi.mode(WIFI_AP);
  WiFi.softAPConfig(local_ip, gateway, subnet);
  // Start the access point
  if(WiFi.softAP(ap_ssid)) 
  {
    Serial.println("WiFi Access Point started successfully");
    Serial.print("AP Name: ");
    Serial.println(ap_ssid);
    Serial.print("AP IP address: ");
    Serial.println(WiFi.softAPIP());
  } 
  else 
    Serial.println("Failed to start WiFi Access Point.");
  // Set up the web server page routes
  server.on("/", handleRoot);
  server.on("/settime", handleSetTime);
  server.onNotFound(handleNotFound);
  // Start the web server
  server.begin();
  Serial.println("Web server started");
  Serial.println("Navigate to http://192.168.4.1 in your web browser to set time");
}