Changes

11 changed files (+1627/-1758)

• SunwaitPi.vcxproj
  • @@ -74,9 +74,9 @@ <ItemGroup>
    <None Include="LICENSE" /> </ItemGroup> <ItemGroup> - <ClCompile Include="print.cpp" /> - <ClCompile Include="sunriset.cpp" /> - <ClCompile Include="sunwait.cpp" /> + <ClCompile Include="print.c" /> + <ClCompile Include="sunriset.c" /> + <ClCompile Include="sunwait.c" /> </ItemGroup> <ItemGroup> <ClInclude Include="print.h" />
  • @@ -94,4 +94,4 @@ </ClCompile>
    </ItemDefinitionGroup> <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" /> <ImportGroup Label="ExtensionTargets" /> - </Project> + </Project>
• makefile
  • @@ -3,19 +3,23 @@ #
    # 08/12/2014 IFC 0.6 No changes since 0.5 # 02/05/2015 IFC 0.7 No changes since 0.5, still # 10/03/2020 TLJ 0.9 Move headers to fix build on osx + # 2022-09-16 DRR 0.91 Accept changes from @mstilkerich Michael Stilkerich switches to C from C++ # - + CFLAGS=-c -Wall -std=c99 -O2 -Wextra -pedantic CXXFLAGS=-c -Wall LDFLAGS= -lm - SOURCES=sunwait.cpp sunriset.cpp print.cpp + SOURCES=sunwait.c sunriset.c print.c HEADERS=sunwait.h sunriset.h print.h - OBJECTS=$(SOURCES:.cpp=.o) + OBJECTS=$(SOURCES:.c=.o) EXECUTABLE=sunwait - all: $(SOURCES) $(EXECUTABLE) + all: $(EXECUTABLE) + + .c.o: + $(CC) $(CFLAGS) $< -o $@ $(EXECUTABLE): $(OBJECTS) - $(CXX) $(OBJECTS) -o $@ $(LDFLAGS) + $(CC) $(OBJECTS) -o $@ $(LDFLAGS) clean: rm -f *.o sunwait
• openwrt/Makefile
  • @@ -17,7 +17,7 @@ SECTION:=util
    CATEGORY:=Utilities TITLE:=Sunwait URL:=URL:=https://github.com/risacher/sunwait - DEPENDS:=+libstdcpp +libc + DEPENDS:=+libc endef define Package/sunwait/description
  • @@ -25,10 +25,10 @@ Wait until the specified solar event
    endef define Build/Compile - $(TARGET_CC) $(TARGET_CPPFLAGS) -o $(PKG_BUILD_DIR)/sunwait.o -c $(PKG_BUILD_DIR)/sunwait.cpp - $(TARGET_CC) $(TARGET_CPPFLAGS) -o $(PKG_BUILD_DIR)/sunriset.o -c $(PKG_BUILD_DIR)/sunriset.cpp - $(TARGET_CC) $(TARGET_CPPFLAGS) -o $(PKG_BUILD_DIR)/print.o -c $(PKG_BUILD_DIR)/print.cpp - $(TARGET_CC) $(TARGET_LDFLAGS) -o $(PKG_BUILD_DIR)/$1 $(PKG_BUILD_DIR)/sunwait.o $(PKG_BUILD_DIR)/sunriset.o $(PKG_BUILD_DIR)/print.o -lm -lstdc++ + $(TARGET_CC) $(TARGET_CPPFLAGS) -o $(PKG_BUILD_DIR)/sunwait.o -c $(PKG_BUILD_DIR)/sunwait.c + $(TARGET_CC) $(TARGET_CPPFLAGS) -o $(PKG_BUILD_DIR)/sunriset.o -c $(PKG_BUILD_DIR)/sunriset.c + $(TARGET_CC) $(TARGET_CPPFLAGS) -o $(PKG_BUILD_DIR)/print.o -c $(PKG_BUILD_DIR)/print.c + $(TARGET_CC) $(TARGET_LDFLAGS) -o $(PKG_BUILD_DIR)/$1 $(PKG_BUILD_DIR)/sunwait.o $(PKG_BUILD_DIR)/sunriset.o $(PKG_BUILD_DIR)/print.o -lm endef define Package/sunwait/install
• print.c (new)
  • @@ -0,0 +1,266 @@
    + + /* + ** print.c (of sunwait) + ** + ** Who Ver When What + ** IFC 0.5 04-12-2014 Fix my 1st release of sunwait for windows and port to linux + ** IFC 0.6 08-12-2014 Add timezone for output of timings + ** IFC 0.7 30-04-2015 Fix timexone and DST trouble - and problems near dateline + ** IFC 0.8 2015-05-27 Resolve 'dodgy day' and cleanup + ** DRR 0.91 2022-09-16 Accept change to C from mstilkerich Michael Stilkerich + ** + */ + + #include <stdio.h> + #include <math.h> + #include <time.h> + + #include "sunwait.h" + #include "sunriset.h" + #include "print.h" + + static const char* cTo = " to "; + static const char* cComma = ", "; + + #define NO_OFFSET 0.0 + + // The user-specified offset reduces the diurnal arc, at sunrise AND sunset. + // But make sure dawn aways is before dusk. The offset can mess that up. + static double diurnalArcWithOffset1 (const double pDiurnalArc, const double pOffset) + { double arcWithOffset = pDiurnalArc - pOffset - pOffset; + if (arcWithOffset >= 24.0) return 24.0; + if (arcWithOffset <= 0.0) return 0.0; + return arcWithOffset; + } + // Simpler to use form + double diurnalArcWithOffset (const runStruct *pRun, const targetStruct *pTarget) + { return diurnalArcWithOffset1 (pTarget->diurnalArc, pRun->offsetHour); + } + + // What time, in hours UTC, is the offset sunrise? + static double getOffsetRiseHourUTC1 (const double pSouthHourUTC, const double pDiurnalArc, const double pOffsetHour) + { return pSouthHourUTC - diurnalArcWithOffset1 (pDiurnalArc, pOffsetHour)/2.0; + } + // Simpler to use form + double getOffsetRiseHourUTC (const runStruct *pRun, const targetStruct *pTarget) + { return getOffsetRiseHourUTC1 (pTarget->southHourUTC, pTarget->diurnalArc, pRun->offsetHour); + } + + // What time, in hours UTC, is the offset sunset? + static double getOffsetSetHourUTC1 (const double pSouthHourUTC, const double pDiurnalArc, const double pOffsetHour) + { return pSouthHourUTC + diurnalArcWithOffset1 (pDiurnalArc, pOffsetHour)/2.0; + } + // Simpler to use form + double getOffsetSetHourUTC (const runStruct *pRun, const targetStruct *pTarget) + { return getOffsetSetHourUTC1 (pTarget->southHourUTC, pTarget->diurnalArc, pRun->offsetHour); + } + + + static void print_a_time + ( const OnOff pGmt_OnOff + , const time_t *pMidnightTimet + , const double pEventHour + ) + { struct tm tmpTm; + char tmpBuffer [80]; + + // Convert current time to struct tm for UTC or local timezone + if (pGmt_OnOff == ONOFF_ON) + { myUtcTime (pMidnightTimet, &tmpTm); + tmpTm.tm_min += (int) (pEventHour * 60.0); + time_t x = mktime (&tmpTm); + myUtcTime (&x, &tmpTm); + } + else + { myLocalTime (pMidnightTimet, &tmpTm); + tmpTm.tm_min += (int) (pEventHour * 60.0); + mktime (&tmpTm); + } + + strftime (tmpBuffer, 80, "%H:%M", &tmpTm); + printf ("%s", tmpBuffer); + } + + static void print_a_sun_time + ( const OnOff pGmt_OnOff + , const time_t *pMidnightTimet + , const double pEventHour + , const double pOffsetDiurnalArc + ) + { // A positive offset reduces the diurnal arc + if (pOffsetDiurnalArc <= 0.0 || pOffsetDiurnalArc >= 24.0) + printf ("--:--"); + else + print_a_time (pGmt_OnOff, pMidnightTimet, pEventHour); + } + + static void print_times + ( const runStruct *pRun + , const targetStruct *pTarget + , const double pOffsetHour + , const char *pSeparator + ) + { double offsetDiurnalArc = diurnalArcWithOffset1 (pTarget->diurnalArc, pOffsetHour); + double riseHour = getOffsetRiseHourUTC1 (pTarget->southHourUTC, pTarget->diurnalArc, pOffsetHour); + double setHour = getOffsetSetHourUTC1 (pTarget->southHourUTC, pTarget->diurnalArc, pOffsetHour); + + if (pRun->reportSunrise == ONOFF_ON) + print_a_sun_time (pRun->utc, &pRun->targetTimet, riseHour, offsetDiurnalArc); + if (pRun->reportSunrise == ONOFF_ON && pRun->reportSunset == ONOFF_ON) + printf ("%s", pSeparator); + if (pRun->reportSunset == ONOFF_ON) + print_a_sun_time (pRun->utc, &pRun->targetTimet, setHour, offsetDiurnalArc); + + if (offsetDiurnalArc >= 24.0) printf (" (Midnight sun)"); + else if (offsetDiurnalArc <= 0.0) printf (" (Polar night)"); + + printf ("\n"); + } + + inline void print_twilight + ( const double pDayLength + , const double pTwilightLength + ) + { printf + ( "%2.2d:%2.2d hours (twilight: %2.2d:%2.2d hours)\n" + , hours (pDayLength), minutes (pDayLength) + , hours (pTwilightLength), minutes (pTwilightLength) + ); + } + + void generate_report (const runStruct *pRun) + { + /* + ** Generate and save sunrise and sunset times for target + */ + + targetStruct tmpTarget; + tmpTarget.twilightAngle = pRun->twilightAngle; + tmpTarget.daysSince2000 = pRun->target2000; + + sunriset (pRun, &tmpTarget); + + double twilightAngleTarget = tmpTarget.twilightAngle; + + /* + ** Now generate the report + */ + + struct tm nowTm; + struct tm targetTm; + char buffer [80]; + + if (pRun->utc == ONOFF_ON) + { myUtcTime (&pRun->nowTimet, &nowTm); + myUtcTime (&pRun->targetTimet, &targetTm); + } + else + { myLocalTime (&pRun->nowTimet, &nowTm); + myLocalTime (&pRun->targetTimet, &targetTm); + } + + printf ("\n"); + + strftime (buffer, 80, "%d-%b-%Y %H:%M %Z", &nowTm); + printf + (" Current Date and Time: %s\n", buffer); + + printf ("\n\nTarget Information ...\n\n"); + + printf + (" Location: %10.6fN, %10.6fE\n" + , pRun->latitude + , pRun->longitude + ); + + strftime (buffer, 80, "%d-%b-%Y", &targetTm); + printf + (" Date: %s\n", buffer); + + strftime (buffer, 80, "%Z", &targetTm); + printf + (" Timezone: %s\n", buffer); + + printf + (" Sun directly north/south: "); + print_a_time (pRun->utc, &pRun->targetTimet, tmpTarget.southHourUTC); + printf ("\n"); + + if (pRun->offsetHour != NO_OFFSET) + { printf + ( " Offset: %2.2d:%2.2d hours\n" + , hours (pRun->offsetHour) + , minutes (pRun->offsetHour) + ); + } + + if (tmpTarget.twilightAngle == TWILIGHT_ANGLE_DAYLIGHT) printf(" Twilight angle: %5.2f degrees (daylight)\n", twilightAngleTarget); + else if (tmpTarget.twilightAngle == TWILIGHT_ANGLE_CIVIL) printf(" Twilight angle: %5.2f degrees (civil)\n", twilightAngleTarget); + else if (tmpTarget.twilightAngle == TWILIGHT_ANGLE_NAUTICAL) printf(" Twilight angle: %5.2f degrees (nautical)\n", twilightAngleTarget); + else if (tmpTarget.twilightAngle == TWILIGHT_ANGLE_ASTRONOMICAL) printf(" Twilight angle: %5.2f degrees (astronomical)\n", twilightAngleTarget); + else printf(" Twilight angle: %5.2f degrees (custom angle)\n", twilightAngleTarget); + + printf (" Day with twilight: "); print_times (pRun, &tmpTarget, NO_OFFSET, cTo); + + if (pRun->offsetHour != NO_OFFSET) + { printf (" Day with twilight & offset: "); print_times (pRun, &tmpTarget, pRun->offsetHour, cTo); } + + printf (" It is: %s\n", isDay (pRun) == ONOFF_ON ? "Day (or twilight)" : "Night"); + + /* + ** Generate times for different types of twilight + */ + + targetStruct daylightTarget; + daylightTarget.twilightAngle = TWILIGHT_ANGLE_DAYLIGHT; + daylightTarget.daysSince2000 = tmpTarget.daysSince2000; + sunriset (pRun, &daylightTarget); + + targetStruct civilTarget; + civilTarget.twilightAngle = TWILIGHT_ANGLE_CIVIL; + civilTarget.daysSince2000 = tmpTarget.daysSince2000; + sunriset (pRun, &civilTarget); + + targetStruct nauticalTarget; + nauticalTarget.twilightAngle = TWILIGHT_ANGLE_NAUTICAL; + nauticalTarget.daysSince2000 = tmpTarget.daysSince2000; + sunriset (pRun, &nauticalTarget); + + targetStruct astronomicalTarget; + astronomicalTarget.twilightAngle = TWILIGHT_ANGLE_ASTRONOMICAL; + astronomicalTarget.daysSince2000 = tmpTarget.daysSince2000; + sunriset (pRun, &astronomicalTarget); + + printf ("\nGeneral Information (no offset) ...\n\n"); + + printf (" Times ... Daylight: "); print_times (pRun, &tmpTarget, NO_OFFSET, cTo); + printf (" with Civil twilight: "); print_times (pRun, &civilTarget, NO_OFFSET, cTo); + printf (" with Nautical twilight: "); print_times (pRun, &nauticalTarget, NO_OFFSET, cTo); + printf (" with Astronomical twilight: "); print_times (pRun, &astronomicalTarget, NO_OFFSET, cTo); + printf ("\n"); + printf (" Duration ... Day length: %2.2d:%2.2d hours\n", hours ( daylightTarget.diurnalArc), minutes ( daylightTarget.diurnalArc)); + printf (" with civil twilight: %2.2d:%2.2d hours\n", hours ( civilTarget.diurnalArc), minutes ( civilTarget.diurnalArc)); + printf (" with nautical twilight: %2.2d:%2.2d hours\n", hours ( nauticalTarget.diurnalArc), minutes ( nauticalTarget.diurnalArc)); + printf (" with astronomical twilight: %2.2d:%2.2d hours\n", hours (astronomicalTarget.diurnalArc), minutes (astronomicalTarget.diurnalArc)); + printf ("\n"); + } + + void print_list (const runStruct *pRun) + { + targetStruct tmpTarget; + + tmpTarget.daysSince2000 = pRun->target2000; + tmpTarget.twilightAngle = pRun->twilightAngle; + + for (unsigned int day=0; day < pRun->listDays; day++) + { + sunriset (pRun, &tmpTarget); + print_times + ( pRun + , &tmpTarget + , pRun->offsetHour + , cComma + ); + tmpTarget.daysSince2000++; + } + }
• print.cpp (deleted)
  • @@ -1,296 +0,0 @@
    - - /* - ** print.cpp (of sunwait) - ** - ** Who Ver When What - ** IFC 0.5 04-12-2014 Fix my 1st release of sunwait for windows and port to linux - ** IFC 0.6 08-12-2014 Add timezone for output of timings - ** IFC 0.7 30-04-2015 Fix timexone and DST trouble - and problems near dateline - ** IFC 0.8 2015-05-27 Resolve 'dodgy day' and cleanup - ** - */ - - #include <stdio.h> - #include <iostream> - #include <math.h> - #include <time.h> - - #include "sunwait.h" - #include "sunriset.h" - #include "print.h" - - static const char* cTo = " to "; - static const char* cComma = ", "; - - #define NO_OFFSET 0.0 - - inline double myDayLength (const double pDouble1, const double pDouble2) - { return myAbs (pDouble1 - pDouble2); - } - - inline double myDayLength (const targetStruct *pTarget) - { return pTarget->diurnalArc; - } - - // The user-specified offset reduces the diurnal arc, at sunrise AND sunset. - // But make sure dawn aways is before dusk. The offset can mess that up. - double diurnalArcWithOffset1 (const double pDiurnalArc, const double pOffset) - { double arcWithOffset = pDiurnalArc - pOffset - pOffset; - if (arcWithOffset >= 24.0) return 24.0; - if (arcWithOffset <= 0.0) return 0.0; - return arcWithOffset; - } - // Simpler to use form - double diurnalArcWithOffset (const runStruct *pRun, const targetStruct *pTarget) - { return diurnalArcWithOffset1 (pTarget->diurnalArc, pRun->offsetHour); - } - - // What time, in hours UTC, is the offset sunrise? - double getOffsetRiseHourUTC1 (const double pSouthHourUTC, const double pDiurnalArc, const double pOffsetHour) - { return pSouthHourUTC - diurnalArcWithOffset1 (pDiurnalArc, pOffsetHour)/2.0; - } - // Simpler to use form - double getOffsetRiseHourUTC (const runStruct *pRun, const targetStruct *pTarget) - { return getOffsetRiseHourUTC1 (pTarget->southHourUTC, pTarget->diurnalArc, pRun->offsetHour); - } - - // What time, in hours UTC, is the offset sunset? - double getOffsetSetHourUTC1 (const double pSouthHourUTC, const double pDiurnalArc, const double pOffsetHour) - { return pSouthHourUTC + diurnalArcWithOffset1 (pDiurnalArc, pOffsetHour)/2.0; - } - // Simpler to use form - double getOffsetSetHourUTC (const runStruct *pRun, const targetStruct *pTarget) - { return getOffsetSetHourUTC1 (pTarget->southHourUTC, pTarget->diurnalArc, pRun->offsetHour); - } - - - void print_a_time - ( const OnOff pGmt_OnOff - , const time_t *pMidnightTimet - , const double pEventHour - ) - { struct tm tmpTm; - char tmpBuffer [80]; - - // Convert current time to struct tm for UTC or local timezone - if (pGmt_OnOff == ONOFF_ON) - { myUtcTime (pMidnightTimet, &tmpTm); - tmpTm.tm_min += (int) (pEventHour * 60.0); - time_t x = mktime (&tmpTm); - myUtcTime (&x, &tmpTm); - } - else - { myLocalTime (pMidnightTimet, &tmpTm); - tmpTm.tm_min += (int) (pEventHour * 60.0); - mktime (&tmpTm); - } - - strftime (tmpBuffer, 80, "%H:%M", &tmpTm); - printf ("%s", tmpBuffer); - } - - void print_a_sun_time - ( const OnOff pGmt_OnOff - , const time_t *pMidnightTimet - , const double pEventHour - , const double pOffsetDiurnalArc - ) - { // A positive offset reduces the diurnal arc - if (pOffsetDiurnalArc <= 0.0 || pOffsetDiurnalArc >= 24.0) - printf ("--:--"); - else - print_a_time (pGmt_OnOff, pMidnightTimet, pEventHour); - } - - void print_times - ( const OnOff pGmt - , const OnOff pSunrise - , const OnOff pSunset - , const time_t pMidnightTimet - , const double pSouthHour - , const double pDiurnalArc - , const double pOffset - , const char *pSeparator - ) - { double offsetDiurnalArc = diurnalArcWithOffset1 (pDiurnalArc, pOffset); - double riseHour = getOffsetRiseHourUTC1 (pSouthHour, pDiurnalArc, pOffset); - double setHour = getOffsetSetHourUTC1 (pSouthHour, pDiurnalArc, pOffset); - - if (pSunrise == ONOFF_ON) - print_a_sun_time (pGmt, &pMidnightTimet, riseHour, offsetDiurnalArc); - if (pSunrise == ONOFF_ON && pSunset == ONOFF_ON) - printf ("%s", pSeparator); - if (pSunset == ONOFF_ON) - print_a_sun_time (pGmt, &pMidnightTimet, setHour, offsetDiurnalArc); - - if (offsetDiurnalArc >= 24.0) printf (" (Midnight sun)"); - else if (offsetDiurnalArc <= 0.0) printf (" (Polar night)"); - - printf ("\n"); - } - - inline void print_times - ( const runStruct *pRun - , const targetStruct *pTarget - , const double pOffsetHour - , const char *pSeparator - ) - { print_times - ( pRun->utc - , pRun->reportSunrise - , pRun->reportSunset - , pRun->targetTimet - , pTarget->southHourUTC - , pTarget->diurnalArc - , pOffsetHour - , pSeparator - ); - } - - inline void print_twilight - ( const double pDayLength - , const double pTwilightLength - ) - { printf - ( "%2.2d:%2.2d hours (twilight: %2.2d:%2.2d hours)\n" - , hours (pDayLength), minutes (pDayLength) - , hours (pTwilightLength), minutes (pTwilightLength) - ); - } - - void generate_report (const runStruct *pRun) - { - /* - ** Generate and save sunrise and sunset times for target - */ - - targetStruct tmpTarget; - tmpTarget.twilightAngle = pRun->twilightAngle; - tmpTarget.daysSince2000 = pRun->target2000; - - sunriset (pRun, &tmpTarget); - - double twilightAngleTarget = tmpTarget.twilightAngle; - - /* - ** Now generate the report - */ - - struct tm nowTm; - struct tm targetTm; - char buffer [80]; - - if (pRun->utc == ONOFF_ON) - { myUtcTime (&pRun->nowTimet, &nowTm); - myUtcTime (&pRun->targetTimet, &targetTm); - } - else - { myLocalTime (&pRun->nowTimet, &nowTm); - myLocalTime (&pRun->targetTimet, &targetTm); - } - - printf ("\n"); - - strftime (buffer, 80, "%d-%b-%Y %H:%M %Z", &nowTm); - printf - (" Current Date and Time: %s\n", buffer); - - printf ("\n\nTarget Information ...\n\n"); - - printf - (" Location: %10.6fN, %10.6fE\n" - , pRun->latitude - , pRun->longitude - ); - - strftime (buffer, 80, "%d-%b-%Y", &targetTm); - printf - (" Date: %s\n", buffer); - - strftime (buffer, 80, "%Z", &targetTm); - printf - (" Timezone: %s\n", buffer); - - printf - (" Sun directly north/south: "); - print_a_time (pRun->utc, &pRun->targetTimet, tmpTarget.southHourUTC); - printf ("\n"); - - if (pRun->offsetHour != NO_OFFSET) - { printf - ( " Offset: %2.2d:%2.2d hours\n" - , hours (pRun->offsetHour) - , minutes (pRun->offsetHour) - ); - } - - if (tmpTarget.twilightAngle == TWILIGHT_ANGLE_DAYLIGHT) printf(" Twilight angle: %5.2f degrees (daylight)\n", twilightAngleTarget); - else if (tmpTarget.twilightAngle == TWILIGHT_ANGLE_CIVIL) printf(" Twilight angle: %5.2f degrees (civil)\n", twilightAngleTarget); - else if (tmpTarget.twilightAngle == TWILIGHT_ANGLE_NAUTICAL) printf(" Twilight angle: %5.2f degrees (nautical)\n", twilightAngleTarget); - else if (tmpTarget.twilightAngle == TWILIGHT_ANGLE_ASTRONOMICAL) printf(" Twilight angle: %5.2f degrees (astronomical)\n", twilightAngleTarget); - else printf(" Twilight angle: %5.2f degrees (custom angle)\n", twilightAngleTarget); - - printf (" Day with twilight: "); print_times (pRun, &tmpTarget, NO_OFFSET, cTo); - - if (pRun->offsetHour != NO_OFFSET) - { printf (" Day with twilight & offset: "); print_times (pRun, &tmpTarget, pRun->offsetHour, cTo); } - - printf (" It is: %s\n", isDay (pRun) == ONOFF_ON ? "Day (or twilight)" : "Night"); - - /* - ** Generate times for different types of twilight - */ - - targetStruct daylightTarget; - daylightTarget.twilightAngle = TWILIGHT_ANGLE_DAYLIGHT; - daylightTarget.daysSince2000 = tmpTarget.daysSince2000; - sunriset (pRun, &daylightTarget); - - targetStruct civilTarget; - civilTarget.twilightAngle = TWILIGHT_ANGLE_CIVIL; - civilTarget.daysSince2000 = tmpTarget.daysSince2000; - sunriset (pRun, &civilTarget); - - targetStruct nauticalTarget; - nauticalTarget.twilightAngle = TWILIGHT_ANGLE_NAUTICAL; - nauticalTarget.daysSince2000 = tmpTarget.daysSince2000; - sunriset (pRun, &nauticalTarget); - - targetStruct astronomicalTarget; - astronomicalTarget.twilightAngle = TWILIGHT_ANGLE_ASTRONOMICAL; - astronomicalTarget.daysSince2000 = tmpTarget.daysSince2000; - sunriset (pRun, &astronomicalTarget); - - printf ("\nGeneral Information (no offset) ...\n\n"); - - printf (" Times ... Daylight: "); print_times (pRun, &tmpTarget, NO_OFFSET, cTo); - printf (" with Civil twilight: "); print_times (pRun, &civilTarget, NO_OFFSET, cTo); - printf (" with Nautical twilight: "); print_times (pRun, &nauticalTarget, NO_OFFSET, cTo); - printf (" with Astronomical twilight: "); print_times (pRun, &astronomicalTarget, NO_OFFSET, cTo); - printf ("\n"); - printf (" Duration ... Day length: %2.2d:%2.2d hours\n", hours ( daylightTarget.diurnalArc), minutes ( daylightTarget.diurnalArc)); - printf (" with civil twilight: %2.2d:%2.2d hours\n", hours ( civilTarget.diurnalArc), minutes ( civilTarget.diurnalArc)); - printf (" with nautical twilight: %2.2d:%2.2d hours\n", hours ( nauticalTarget.diurnalArc), minutes ( nauticalTarget.diurnalArc)); - printf (" with astronomical twilight: %2.2d:%2.2d hours\n", hours (astronomicalTarget.diurnalArc), minutes (astronomicalTarget.diurnalArc)); - printf ("\n"); - } - - void print_list (const runStruct *pRun) - { - targetStruct tmpTarget; - - tmpTarget.daysSince2000 = pRun->target2000; - tmpTarget.twilightAngle = pRun->twilightAngle; - - for (unsigned int day=0; day < pRun->listDays; day++) - { - sunriset (pRun, &tmpTarget); - print_times - ( pRun - , &tmpTarget - , pRun->offsetHour - , cComma - ); - tmpTarget.daysSince2000++; - } - }
• print.h
  • @@ -4,6 +4,7 @@ //
    // 08-12-2014 IFC 0.6 No changes from 0.5 // 02-05-2015 IFC 0.7 No changes from 0.5, still // 2015-05-27 IFC 0.8 Resolve 'dodgy day' and cleanup + // 2022-09-16 DRR 0.91 Convert to C courtesy mstilkerich // #ifndef PRINT_H
  • @@ -12,15 +13,12 @@
    #include "sunwait.h" #include "sunriset.h" - void generate_report (const runStruct *pRun); + void generate_report(const runStruct *pRun); void print_list (const runStruct *pRun); - double diurnalArcWithOffsetX (const double pDiurnalArc, const double pOffset); double diurnalArcWithOffset (const runStruct *pRun, const targetStruct *pTarget); - double getOffsetRiseHourUTCX (const double pSouthHourUTC, const double pDiurnalArc, const double pOffsetHour); double getOffsetRiseHourUTC (const runStruct *pRun, const targetStruct *pTarget); - double getOffsetSetHourUTCX (const double pSouthHourUTC, const double pDiurnalArc, const double pOffsetHour); double getOffsetSetHourUTC (const runStruct *pRun, const targetStruct *pTarget);
• sunriset.c (new)
  • @@ -0,0 +1,288 @@
    + /* + ** sunriset.c - computes Sun rise/set times, including twilights + ** Written as DAYLEN.C, 1989-08-16 + ** Modified to SUNRISET.C, 1992-12-01 + ** (c) Paul Schlyter, 1989, 1992 + ** Released to the public domain by Paul Schlyter, December 1992 + */ + + /* + ** + ** Who When Ver What + ** IFC 04-12-2014 0.5 General fixes to "sunwait for windows" and linux port + ** IFC 08-12-2014 0.6 Add timezone for output of timings + ** IFC 29-04-2015 0.7 Fix for timezone (esp near date line) and more debug + ** IFC 2015-05-27 0.8 Resolve 'dodgy day' and cleanup + ** DRR 2022-09-16 0.91 Move to C courtesy mstilkerich + ** + */ + + #include <stdio.h> + + #include <math.h> + #include <time.h> + + #include "sunwait.h" + #include "sunriset.h" + + /************************************************************************/ + /* Note: Eastern longitude positive, Western longitude negative */ + /* Northern latitude positive, Southern latitude negative */ + /* */ + /* >>> Longitude value IS critical in this function! <<< */ + /* */ + /* days = Days since 2000 plus fraction to local noon */ + /* altit = the altitude which the Sun should cross */ + /* Set to -35/60 degrees for rise/set, -6 degrees */ + /* for civil, -12 degrees for nautical and -18 */ + /* degrees for astronomical twilight. */ + /* upper_limb: non-zero -> upper limb, zero -> center */ + /* Set to non-zero (e.g. 1) when computing rise/set */ + /* times, and to zero when computing start/end of */ + /* twilight. */ + /* */ + /* Both times are relative to the specified altitude, */ + /* and thus this function can be used to comupte */ + /* various twilight times, as well as rise/set times */ + /* Return Codes: */ + /* 0 = sun rises/sets this day. Success. */ + /* Times held at *trise and *tset. */ + /* +1 = Midnight Sun. Fail. */ + /* Sun above the specified "horizon" all 24 hours. */ + /* *trise set to time when the sun is at south, */ + /* minus 12 hours while *tset is set to the south */ + /* time plus 12 hours. "Day" length = 24 hours */ + /* -1 = Polar Night. Fail. */ + /* Sun is below the specified "horizon" all 24hours. */ + /* "Day" length = 0 hours, *trise and *tset are */ + /* both set to the time when the sun is at south. */ + /* */ + /************************************************************************/ + void sunriset (const runStruct *pRun, targetStruct *pTarget) + { + double sr; /* solar distance, astronomical units */ + double sra; /* sun's right ascension */ + double sdec; /* sun's declination */ + double sradius; /* sun's apparent radius */ + double siderealTime; /* local sidereal time */ + double altitude; /* sun's altitude: angle to the sun relative to the mathematical (flat-earth) horizon */ + double diurnalArc = 0.0; /* the diurnal arc, hours */ + double southHour = 0.0; /* Hour UTC the sun is directly south (or north for southern Hemisphere) of lat/long position */ + + /* compute sideral time at 00:00 UTC of target day for this longitude. */ + siderealTime = revolution (GMST0(pTarget->daysSince2000) + 180.0 + pRun->longitude); // 180 = 0 hour UTC is measured 180 degrees from dateline + + /* compute sun's ra + decl at this moment */ + sun_RA_dec (pTarget->daysSince2000, &sra, &sdec, &sr ); + + /* compute time when sun is directly south - in hours UTC. "12.00" == noon. "15" == 180degrees/12hours [degrees per hour] */ + southHour = 12.0 - rev180 (siderealTime - sra)/15.0; + + /* compute the sun's apparent radius, degrees */ + sradius = 0.2666 / sr; // Apparent angular radius of sun is 0.2666/distance in AU (deg) + + /* Do correction for upper limb ('top' of sun) only, for "daylight" sunrise or set. Otherwise calculate for centre of sun */ + if (pTarget->twilightAngle == TWILIGHT_ANGLE_DAYLIGHT) + altitude = pTarget->twilightAngle - sradius; + else + altitude = pTarget->twilightAngle; + + /* compute the diurnal arc that the sun traverses to reach the specified altitide altit: */ + double cost = (sind(altitude) - sind(pRun->latitude) * sind(sdec)) / (cosd(pRun->latitude) * cosd(sdec)); + + if (cost > -1.0 && cost < 1.0) + diurnalArc = 2*acosd(cost)/15.0; /* Diurnal arc, hours */ + else if (cost >= 1.0) + diurnalArc = 0.0; // Polar Night + else + diurnalArc = 24.0; // Midnight Sun + + if (pRun->debug == ONOFF_ON) + { printf ("Debug: %s: Sun directly south: %f UTC, Diurnal Arc = %f hours\n", __FILE__, southHour, diurnalArc); + printf ("Debug: %s: Days since 2000: %li\n", __FILE__, pTarget->daysSince2000); + if (diurnalArc >= 24.0) printf ("Debug: %s: No rise or set: Midnight Sun\n", __FILE__); + if (diurnalArc <= 0.0) printf ("Debug: %s: No rise or set: Polar Night\n", __FILE__); + } + + // Error Check - just make sure odd things don't happen (causing trouble further on) + if (diurnalArc > 24.0) diurnalArc = 24.0; + if (diurnalArc < 0.0) diurnalArc = 0.0; + + /* Apply values */ + pTarget->southHourUTC = southHour; + pTarget->diurnalArc = diurnalArc; + } + + void sunpos (const double d, double *lon, double *r) + /******************************************************/ + /* Computes the Sun's ecliptic longitude and distance */ + /* at an instant given in d, number of days since */ + /* 2000 Jan 0.0. The Sun's ecliptic latitude is not */ + /* computed, since it's always very near 0. */ + /******************************************************/ + { + double M, /* Mean anomaly of the Sun */ + w, /* Mean longitude of perihelion */ + /* Note: Sun's mean longitude = M + w */ + e, /* Eccentricity of Earth's orbit */ + E, /* Eccentric anomaly */ + x, y, /* x, y coordinates in orbit */ + v; /* True anomaly */ + + /* Compute mean elements */ + M = revolution (356.0470 + 0.9856002585 * d); + w = 282.9404 + 4.70935E-5 * d; + e = 0.016709 - 1.151E-9 * d; + + /* Compute true longitude and radius vector */ + E = M + e * RADIAN_TO_DEGREE * sind(M) * (1.0 + e * cosd(M)); + x = cosd (E) - e; + y = sqrt (1.0 - e*e) * sind(E); + *r = sqrt (x*x + y*y); /* Solar distance */ + v = atan2d (y, x); /* True anomaly */ + *lon = revolution (v + w); /* True solar longitude, made 0..360 degrees */ + } + + void sun_RA_dec (const double d, double *RA, double *dec, double *r) + { + double lon, obl_ecl; + double xs, ys; + double xe, ye, ze; + + /* Compute Sun's ecliptical coordinates */ + sunpos (d, &lon, r); + + /* Compute ecliptic rectangular coordinates */ + xs = *r * cosd(lon); + ys = *r * sind(lon); + + /* Compute obliquity of ecliptic (inclination of Earth's axis) */ + obl_ecl = 23.4393 - 3.563E-7 * d; + + /* Convert to equatorial rectangular coordinates - x is unchanged */ + xe = xs; + ye = ys * cosd(obl_ecl); + ze = ys * sind(obl_ecl); + + /* Convert to spherical coordinates */ + *RA = atan2d(ye, xe); + *dec = atan2d(ze, sqrt(xe*xe + ye*ye)); + } + + // + // Utility functions + // + + // Reduce angle to within 0..359.999 degrees + double revolution (const double x) + { double remainder = fmod (x, (double) 360.0); + return remainder < (double) 0.0 ? remainder + (double) 360.0 : remainder; + } + + // Reduce angle to -179.999 to +180 degrees + double rev180 (const double x) + { double y = revolution (x); + return y <= (double) 180.0 ? y : y - (double) 360.0; + } + + // Fix angle to 0-359.999 + double fixLongitude (const double x) + { return revolution (x); + } + + // Fix angle to 0-89.999 and -0.001 to -89.999 + double fixLatitude (const double x) + { + // Make angle 0 to 359.9999 + double y = revolution (x); + + if (y <= (double) 90.0) ; + else if (y <= (double) 180.0) y = (double) 180.0 - y; + else if (y <= (double) 270.0) y = (double) 180.0 - y; + else if (y <= (double) 360.0) y = y - (double) 360.0; + + // Linux compile of sunwait doesn't like 90, Windows is OK. + // Let's just wiggle things a little bit to make things OK. + if (y == (double) 90.0) y = (double) 89.9999999; + else if (y == (double) -90.0) y = (double) -89.9999999; + + return y; + } + + // Time must be between 0:00 amd 23:59 + double fix24 (const double x) + { + double remainder = fmod (x, (double) 24.0); + return remainder < (double) 0.0 ? remainder + (double) 24.0 : remainder; + } + + /*******************************************************************/ + /* This function computes GMST0, the Greenwhich Mean Sidereal Time */ + /* at 0h UT (i.e. the sidereal time at the Greenwhich meridian at */ + /* 0h UT). GMST is then the sidereal time at Greenwich at any */ + /* time of the day. I've generalized GMST0 as well, and define it */ + /* as: GMST0 = GMST - UT -- this allows GMST0 to be computed at */ + /* other times than 0h UT as well. While this sounds somewhat */ + /* contradictory, it is very practical: instead of computing */ + /* GMST like: */ + /* */ + /* GMST = (GMST0) + UT * (366.2422/365.2422) */ + /* */ + /* where (GMST0) is the GMST last time UT was 0 hours, one simply */ + /* computes: */ + /* */ + /* GMST = GMST0 + UT */ + /* */ + /* where GMST0 is the GMST "at 0h UT" but at the current moment! */ + /* Defined in this way, GMST0 will increase with about 4 min a */ + /* day. It also happens that GMST0 (in degrees, 1 hr = 15 degr) */ + /* is equal to the Sun's mean longitude plus/minus 180 degrees! */ + /* (if we neglect aberration, which amounts to 20 seconds of arc */ + /* or 1.33 seconds of time) */ + /* */ + /*******************************************************************/ + + inline double GMST0 (const double d) + { + /* Sidtime at 0h UT = L (Sun's mean longitude) + 180.0 degr */ + /* L = M + w, as defined in sunpos(). Since I'm too lazy to */ + /* add these numbers, I'll let the C compiler do it for me. */ + /* Any decent C compiler will add the constants at compile */ + /* time, imposing no runtime or code overhead. */ + return revolution ((180.0 + 356.0470 + 282.9404) + (0.9856002585 + 4.70935E-5) * d); + } + + + unsigned long daysSince2000 (const time_t *pTimet) + { + struct tm tmpTm; + + myUtcTime (pTimet, &tmpTm); + + unsigned int yearsSince2000 = tmpTm.tm_year - 100; // Get year, but tm_year starts from 1900 + + // Calucate number of leap days, but - + // yearsSince2000 - 1 + // Don't include this year as tm_yday includes this year's leap day in the next bit + + unsigned int leapDaysSince2000 + = (unsigned int) floor ((yearsSince2000-1)/4) // Every evenly divisible 4 years is a leap-year + - (unsigned int) floor ((yearsSince2000-1)/100) // Except centuries + + (unsigned int) floor ((yearsSince2000-1)/400) // Unless evenlt divisible by 400 + + 1; // 2000 itself was a leap year with the 400 rule (a fix for 0/400 == 0) + + return (yearsSince2000 * 365) + leapDaysSince2000 + tmpTm.tm_yday; + } + + /* + ** Utility functions + */ + + long myRound (const double d) { return d > 0.0 ? (int) (d + 0.5) : (int) (d - 0.5) ; } + long myTrunc (const double d) { return (d>0) ? (int) floor(d) : (int) ceil(d) ; } + double myAbs (const double d) { return (d>0) ? d : -d ; } + + int hours (const double d) { return myTrunc (d); } + int minutes (const double d) { return myTrunc (fmod (myAbs (d) * 60, 60)); } + +
• sunriset.cpp (deleted)
  • @@ -1,290 +0,0 @@
    - /* - ** sunriset.c - computes Sun rise/set times, including twilights - ** Written as DAYLEN.C, 1989-08-16 - ** Modified to SUNRISET.C, 1992-12-01 - ** (c) Paul Schlyter, 1989, 1992 - ** Released to the public domain by Paul Schlyter, December 1992 - */ - - /* - ** - ** Who When Ver What - ** IFC 04-12-2014 0.5 General fixes to "sunwait for windows" and linux port - ** IFC 08-12-2014 0.6 Add timezone for output of timings - ** IFC 29-04-2015 0.7 Fix for timezone (esp near date line) and more debug - ** IFC 2015-05-27 0.8 Resolve 'dodgy day' and cleanup - ** - */ - - #include <stdio.h> - #include <stdlib.h> // Linux - #include <iostream> - #include <math.h> - #include <time.h> - - #include "sunwait.h" - #include "sunriset.h" - - using namespace std; - - /************************************************************************/ - /* Note: Eastern longitude positive, Western longitude negative */ - /* Northern latitude positive, Southern latitude negative */ - /* */ - /* >>> Longitude value IS critical in this function! <<< */ - /* */ - /* days = Days since 2000 plus fraction to local noon */ - /* altit = the altitude which the Sun should cross */ - /* Set to -35/60 degrees for rise/set, -6 degrees */ - /* for civil, -12 degrees for nautical and -18 */ - /* degrees for astronomical twilight. */ - /* upper_limb: non-zero -> upper limb, zero -> center */ - /* Set to non-zero (e.g. 1) when computing rise/set */ - /* times, and to zero when computing start/end of */ - /* twilight. */ - /* */ - /* Both times are relative to the specified altitude, */ - /* and thus this function can be used to comupte */ - /* various twilight times, as well as rise/set times */ - /* Return Codes: */ - /* 0 = sun rises/sets this day. Success. */ - /* Times held at *trise and *tset. */ - /* +1 = Midnight Sun. Fail. */ - /* Sun above the specified "horizon" all 24 hours. */ - /* *trise set to time when the sun is at south, */ - /* minus 12 hours while *tset is set to the south */ - /* time plus 12 hours. "Day" length = 24 hours */ - /* -1 = Polar Night. Fail. */ - /* Sun is below the specified "horizon" all 24hours. */ - /* "Day" length = 0 hours, *trise and *tset are */ - /* both set to the time when the sun is at south. */ - /* */ - /************************************************************************/ - void sunriset (const runStruct *pRun, targetStruct *pTarget) - { - double sr; /* solar distance, astronomical units */ - double sra; /* sun's right ascension */ - double sdec; /* sun's declination */ - double sradius; /* sun's apparent radius */ - double siderealTime; /* local sidereal time */ - double altitude; /* sun's altitude: angle to the sun relative to the mathematical (flat-earth) horizon */ - double diurnalArc = 0.0; /* the diurnal arc, hours */ - double southHour = 0.0; /* Hour UTC the sun is directly south (or north for southern Hemisphere) of lat/long position */ - - /* compute sideral time at 00:00 UTC of target day for this longitude. */ - siderealTime = revolution (GMST0(pTarget->daysSince2000) + 180.0 + pRun->longitude); // 180 = 0 hour UTC is measured 180 degrees from dateline - - /* compute sun's ra + decl at this moment */ - sun_RA_dec (pTarget->daysSince2000, &sra, &sdec, &sr ); - - /* compute time when sun is directly south - in hours UTC. "12.00" == noon. "15" == 180degrees/12hours [degrees per hour] */ - southHour = 12.0 - rev180 (siderealTime - sra)/15.0; - - /* compute the sun's apparent radius, degrees */ - sradius = 0.2666 / sr; // Apparent angular radius of sun is 0.2666/distance in AU (deg) - - /* Do correction for upper limb ('top' of sun) only, for "daylight" sunrise or set. Otherwise calculate for centre of sun */ - if (pTarget->twilightAngle == TWILIGHT_ANGLE_DAYLIGHT) - altitude = pTarget->twilightAngle - sradius; - else - altitude = pTarget->twilightAngle; - - /* compute the diurnal arc that the sun traverses to reach the specified altitide altit: */ - double cost = (sind(altitude) - sind(pRun->latitude) * sind(sdec)) / (cosd(pRun->latitude) * cosd(sdec)); - - if (abs(int(cost)) < 1.0) - diurnalArc = 2*acosd(cost)/15.0; /* Diurnal arc, hours */ - else if (cost>=1.0) - diurnalArc = 0.0; // Polar Night - else - diurnalArc = 24.0; // Midnight Sun - - if (pRun->debug == ONOFF_ON) - { printf ("Debug: sunriset.cpp: Sun directly south: %f UTC, Diurnal Arc = %f hours\n", southHour, diurnalArc); - printf ("Debug: sunriset.cpp: Days since 2000: %li\n", pTarget->daysSince2000); - if (diurnalArc >= 24.0) printf ("Debug: sunriset.cpp: No rise or set: Midnight Sun\n"); - if (diurnalArc <= 0.0) printf ("Debug: sunriset.cpp: No rise or set: Polar Night\n"); - } - - // Error Check - just make sure odd things don't happen (causing trouble further on) - if (diurnalArc > 24.0) diurnalArc = 24.0; - if (diurnalArc < 0.0) diurnalArc = 0.0; - - /* Apply values */ - pTarget->southHourUTC = southHour; - pTarget->diurnalArc = diurnalArc; - } - - void sunpos (const double d, double *lon, double *r) - /******************************************************/ - /* Computes the Sun's ecliptic longitude and distance */ - /* at an instant given in d, number of days since */ - /* 2000 Jan 0.0. The Sun's ecliptic latitude is not */ - /* computed, since it's always very near 0. */ - /******************************************************/ - { - double M, /* Mean anomaly of the Sun */ - w, /* Mean longitude of perihelion */ - /* Note: Sun's mean longitude = M + w */ - e, /* Eccentricity of Earth's orbit */ - E, /* Eccentric anomaly */ - x, y, /* x, y coordinates in orbit */ - v; /* True anomaly */ - - /* Compute mean elements */ - M = revolution (356.0470 + 0.9856002585 * d); - w = 282.9404 + 4.70935E-5 * d; - e = 0.016709 - 1.151E-9 * d; - - /* Compute true longitude and radius vector */ - E = M + e * RADIAN_TO_DEGREE * sind(M) * (1.0 + e * cosd(M)); - x = cosd (E) - e; - y = sqrt (1.0 - e*e) * sind(E); - *r = sqrt (x*x + y*y); /* Solar distance */ - v = atan2d (y, x); /* True anomaly */ - *lon = revolution (v + w); /* True solar longitude, made 0..360 degrees */ - } - - void sun_RA_dec (const double d, double *RA, double *dec, double *r) - { - double lon, obl_ecl; - double xs, ys; - double xe, ye, ze; - - /* Compute Sun's ecliptical coordinates */ - sunpos (d, &lon, r); - - /* Compute ecliptic rectangular coordinates */ - xs = *r * cosd(lon); - ys = *r * sind(lon); - - /* Compute obliquity of ecliptic (inclination of Earth's axis) */ - obl_ecl = 23.4393 - 3.563E-7 * d; - - /* Convert to equatorial rectangular coordinates - x is unchanged */ - xe = xs; - ye = ys * cosd(obl_ecl); - ze = ys * sind(obl_ecl); - - /* Convert to spherical coordinates */ - *RA = atan2d(ye, xe); - *dec = atan2d(ze, sqrt(xe*xe + ye*ye)); - } - - // - // Utility functions - // - - // Reduce angle to within 0..359.999 degrees - double revolution (const double x) - { double remainder = fmod (x, (double) 360.0); - return remainder < (double) 0.0 ? remainder + (double) 360.0 : remainder; - } - - // Reduce angle to -179.999 to +180 degrees - double rev180 (const double x) - { double y = revolution (x); - return y <= (double) 180.0 ? y : y - (double) 360.0; - } - - // Fix angle to 0-359.999 - double fixLongitude (const double x) - { return revolution (x); - } - - // Fix angle to 0-89.999 and -0.001 to -89.999 - double fixLatitude (const double x) - { - // Make angle 0 to 359.9999 - double y = revolution (x); - - if (y <= (double) 90.0) ; - else if (y <= (double) 180.0) y = (double) 180.0 - y; - else if (y <= (double) 270.0) y = (double) 180.0 - y; - else if (y <= (double) 360.0) y = y - (double) 360.0; - - // Linux compile of sunwait doesn't like 90, Windows is OK. - // Let's just wiggle things a little bit to make things OK. - if (y == (double) 90.0) y = (double) 89.9999999; - else if (y == (double) -90.0) y = (double) -89.9999999; - - return y; - } - - // Time must be between 0:00 amd 23:59 - double fix24 (const double x) - { - double remainder = fmod (x, (double) 24.0); - return remainder < (double) 0.0 ? remainder + (double) 24.0 : remainder; - } - - /*******************************************************************/ - /* This function computes GMST0, the Greenwhich Mean Sidereal Time */ - /* at 0h UT (i.e. the sidereal time at the Greenwhich meridian at */ - /* 0h UT). GMST is then the sidereal time at Greenwich at any */ - /* time of the day. I've generalized GMST0 as well, and define it */ - /* as: GMST0 = GMST - UT -- this allows GMST0 to be computed at */ - /* other times than 0h UT as well. While this sounds somewhat */ - /* contradictory, it is very practical: instead of computing */ - /* GMST like: */ - /* */ - /* GMST = (GMST0) + UT * (366.2422/365.2422) */ - /* */ - /* where (GMST0) is the GMST last time UT was 0 hours, one simply */ - /* computes: */ - /* */ - /* GMST = GMST0 + UT */ - /* */ - /* where GMST0 is the GMST "at 0h UT" but at the current moment! */ - /* Defined in this way, GMST0 will increase with about 4 min a */ - /* day. It also happens that GMST0 (in degrees, 1 hr = 15 degr) */ - /* is equal to the Sun's mean longitude plus/minus 180 degrees! */ - /* (if we neglect aberration, which amounts to 20 seconds of arc */ - /* or 1.33 seconds of time) */ - /* */ - /*******************************************************************/ - - inline double GMST0 (const double d) - { - /* Sidtime at 0h UT = L (Sun's mean longitude) + 180.0 degr */ - /* L = M + w, as defined in sunpos(). Since I'm too lazy to */ - /* add these numbers, I'll let the C compiler do it for me. */ - /* Any decent C compiler will add the constants at compile */ - /* time, imposing no runtime or code overhead. */ - return revolution ((180.0 + 356.0470 + 282.9404) + (0.9856002585 + 4.70935E-5) * d); - } - - - unsigned long daysSince2000 (const time_t *pTimet) - { - struct tm tmpTm; - - myUtcTime (pTimet, &tmpTm); - - unsigned int yearsSince2000 = tmpTm.tm_year - 100; // Get year, but tm_year starts from 1900 - - // Calucate number of leap days, but - - // yearsSince2000 - 1 - // Don't include this year as tm_yday includes this year's leap day in the next bit - - unsigned int leapDaysSince2000 - = (unsigned int) floor ((yearsSince2000-1)/4) // Every evenly divisible 4 years is a leap-year - - (unsigned int) floor ((yearsSince2000-1)/100) // Except centuries - + (unsigned int) floor ((yearsSince2000-1)/400) // Unless evenlt divisible by 400 - + 1; // 2000 itself was a leap year with the 400 rule (a fix for 0/400 == 0) - - return (yearsSince2000 * 365) + leapDaysSince2000 + tmpTm.tm_yday; - } - - /* - ** Utility functions - */ - - long myRound (const double d) { return d > 0.0 ? (int) (d + 0.5) : (int) (d - 0.5) ; } - long myTrunc (const double d) { return (d>0) ? (int) floor(d) : (int) ceil(d) ; } - double myAbs (const double d) { return (d>0) ? d : -d ; } - - int hours (const double d) { return myTrunc (d); } - int minutes (const double d) { return myTrunc (fmod (myAbs (d) * 60, 60)); } - -
• sunwait.c (new)
  • @@ -0,0 +1,1049 @@
    + // sunwait.cpp : Defines the entry point for the console application. + // + + // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv CHANGE ME + // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv CHANGE ME + const double VERSION=0.91; // <<<<<<<<< CHANGE ME + // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ CHANGE ME + // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ CHANGE ME + + /* copyright (c) 2000,2004,2022 Daniel Risacher */ + /* minor changes courtesy of Dr. David M. MacMillan */ + /* major changes courtesy of Ian Craig (2012-13) */ + /* Licensed under the Gnu General Public License */ + + // Who When Ver What + // IFC 2013-07-13 0.4 Working version of "sunwait", ported to Windows. + // IFC 2014-12-01 0.5 The linux port was not working - the windows sleep is for seconds, the linux is miliseconds. + // I'm porting my home power control to Linux, so I've reworked the whole program to suit. + // IFC 2014-12-08 0.6 Add timezone handling for output - if required + // IFC 2015-04-29 0.7 Timezone and DST fixes - and for date line timings + // IFC 2015-05-27 0.8 Resolve 'dodgy day' and cleanup + // TLJ 2020-10-03 0.9 Fix build on osx + // DRR 2022-09-16 0.91 Fix build with modern GCC + // + + #include <stdio.h> + #include <stdlib.h> + #include <string.h> + #include <ctype.h> + #include <time.h> + #include <math.h> + #include <stdbool.h> + + // Windows + #if defined _WIN32 || defined _WIN64 + #include <windows.h> + + static void sleepSeconds(unsigned int seconds) + { + Sleep(1000u * seconds); + } + // Linux + #elif defined __linux__ || defined __APPLE__ || defined __unix__ + #include <unistd.h> + + static void sleepSeconds(unsigned int seconds) + { + while (seconds > 0u) { + seconds = sleep(seconds); + } + } + #else + // die with an error - otherwise, the compilation will appear to succeed, but + // the resulting program will not work correctly + #error "Unsupported platform" + #endif + + #include "sunwait.h" + #include "sunriset.h" + #include "print.h" + + /* + ** Define global: + ** 'runStruct' structure allows pretty much everything to be carted simply around functions. + ** 'targetStruct' structure is the interface to the sunrise calcs. Compact, and allows multi-results to be used. + ** It can be a bit naughty on side-effects, so I use 'const' where-ever I can. + */ + + runStruct gRun; + runStruct *pRun; + + static void print_version () + { + printf ("Sunwait Version %f.\n", VERSION); + printf ("Code Contributors: P.Schlyter, D.Risacher, D.MacMillan, I.Craig, et al.\n"); + printf ("\n"); + printf (" Sunset is the instant at which the upper edge of the Sun disappears below the horizon.\n"); + printf (" Civil twilight is the period from sunset until the geometric centre of the sun is 6° below the horizon.\n"); + printf (" Nautical twilight is the period when the geometric centre of the sun is between 6° and 12° below the horizon.\n"); + printf (" Astronomical twilight is the period when the geometric centre of the sun is between 12° and 18° below the horizon.\n"); + printf (" Night is period when the geometric center of the sun falls 18° below the horizon.\n"); + } + + /* + ** It's very useful to have this here + */ + static void print_usage () + { printf ("Calculate sunrise and sunset times for the current or targetted day.\n"); + printf ("The times can be adjusted either for twilight or fixed durations.\n"); + printf ("\n"); + printf ("The program can either: wait for sunrise or sunset (function: wait),\n"); + printf (" or return the time (GMT or local) the event occurs (function: list),\n"); + printf (" or report the day length and twilight timings (function: report),\n"); + printf (" or simply report if it is DAY or NIGHT (function: poll).\n"); + printf ("\n"); + printf ("You should specify the latitude and longitude of your target location.\n"); + printf ("\n"); + printf ("\n"); + printf ("Usage: sunwait [major options] [minor options] [twilight type] [rise|set] [offset] [latitude] [longitude]\n"); + printf ("\n"); + printf ("Major options, either:\n"); + printf (" poll Returns immediately indicating DAY or NIGHT. See 'program exit codes'. Default.\n"); + printf (" wait Sleep until specified event occurs. Else exit immediate.\n"); + printf (" list [X] Report twilight times for next 'X' days (inclusive). Default: %u.\n", DEFAULT_LIST); + printf (" report Generate a report about the days sunrise and sunset timings.\n"); + printf ("\n"); + printf ("Minor options, any of:\n"); + printf (" [no]debug Print extra info and returns in one minute. Default: nodebug.\n"); + printf (" [no]version Print the version number. Default: noversion.\n"); + printf (" [no]help Print this help. Default: nohelp.\n"); + printf (" [no]gmt Print times in GMT or local-time. Default: nogmt.\n"); + printf ("\n"); + printf ("Twilight types, either:\n"); + printf (" daylight Top of sun just below the horizon. Default.\n"); + printf (" civil Civil Twilight. -6 degrees below horizon.\n"); + printf (" nautical Nautical twilight. -12 degrees below horizon.\n"); + printf (" astronomical Astronomical twilight. -18 degrees below horizon.\n"); + printf (" angle [X.XX] User-specified twilight-angle (degrees). Default: 0.\n"); + printf ("\n"); + printf ("Sunrise/sunset. Only useful with major-options: 'wait' and 'list'. Any of: (default: both)\n"); + printf (" rise Wait for the sun to rise past specified twilight & offset.\n"); + printf (" set Wait for the sun to set past specified twilight & offset.\n"); + printf ("\n"); + printf ("Offset:\n"); + printf (" offset [MM|HH:MM] Time interval (+ve towards noon) to adjust twilight calculation.\n"); + printf ("\n"); + printf ("Target date. Only useful with major-options: 'report' or 'list'. Default: today\n"); + printf (" d [DD] Set the target Day-of-Month to calculate for. 1 to 31.\n"); + printf (" m [MM] Set the target Month to calculate for. 1 to 12.\n"); + printf (" y [YYYY] Set the target Year to calculate for. 2000 to 2099.\n"); + printf ("\n"); + printf ("latitude/longitude coordinates: floating-point degrees, with [NESW] appended. Default: Bingham, England.\n"); + printf ("\n"); + printf ("Exit (return) codes:\n"); + printf (" %1d OK: exit from 'wait' or 'list' only.\n", EXIT_OK); + printf (" %1d Error.\n", EXIT_ERROR); + printf (" %1d Exit from 'poll': it is DAY or twilight.\n", EXIT_DAY); + printf (" %1d Exit from 'poll': it is NIGHT (after twilight).\n", EXIT_NIGHT); + printf ("\n"); + printf ("Example 1: sunwait wait rise offset -1:15:10 51.477932N 0.000000E\n"); + printf ("Wait until 1 hour 15 minutes 10 secs before the sun rises in Greenwich, London.\n"); + printf ("\n"); + printf ("Example 2: sunwait list 7 civil 55.752163N 37.617524E\n"); + printf ("List civil sunrise and sunset times for today and next 6 days. Moscow.\n"); + printf ("\n"); + printf ("Example 3: sunwait poll exit angle 10 54.897786N -1.517536E\n"); + printf ("Indicate by program exit-code if is Day or Night using a custom twilight angle of 10 degrees above horizon. Washington, UK.\n"); + printf ("\n"); + printf ("Example 4: sunwait list 7 gmt sunrise angle 3\n"); + printf ("List next 7 days sunrise times, custom +3 degree twilight angle, default location.\n"); + printf ("Uses GMT; as any change in daylight saving over the specified period is not considered.\n"); + printf ("\n"); + printf ("Note that program uses C library functions to determine time and localtime.\n"); + printf ("Error for timings are estimated at: +/- 4 minutes.\n"); + printf ("\n"); + } + + static void stringToLower (char *arg) + { for (unsigned int i=0; i < strlen (arg); i++) + arg[i] = tolower (arg[i]); + } + + static void stringsToLower (const int argc, char *argv[]) + { for (int i=1; i < argc; i++) + stringToLower (argv [i]); + } + + static bool myIsNumber (const char *arg) + { bool digitSet = false; + for (int i=0; ; i++) + { switch (arg[i]) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': digitSet = true; break; + case '-': + case '+': if (digitSet) return false; break; + case '\0': return digitSet; break; // Exit OK + default: return false; // Exit Error + } + } + return false; /* Shouldn't get here */ + } + + static bool myIsSignedNumber (const char *arg) + { bool digitSet = false; + for (int i=0; ; i++) + { switch (arg[i]) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': digitSet = true; break; + case '+': + case '-': if (i>0) return false; break; /* Sign only at start */ + case '\0': return digitSet; break; // Exit OK + default: return false; // Exit Error + } + } + return false; /* Shouldn't get here */ + } + + static bool myIsSignedFloat (const char *arg) + { bool digitSet = false; + for (int i=0; ; i++) + { switch (arg[i]) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': digitSet = true; break; + case '.': break; /* Can be anywhere (but in front of sign), or not there */ + case '+': + case '-': if (i>0) return false; break; /* Sign only at start */ + case '\0': return digitSet; break; // Exit OK + default: return false; // Exit Error + } + } + return false; /* Shouldn't get here */ + } + + static bool isBearing (runStruct *pRun, const char *pArg) + { double bearing = 0; + int exponent = 0; + bool negativeBearing = false; + bool exponentSet = false; + char compass = 'X'; + + for (int i=0; ; i++) + { switch (pArg[i]) + { + case '0': bearing = (bearing*10) + 0; exponentSet?exponent++:true; break; + case '1': bearing = (bearing*10) + 1; exponentSet?exponent++:true; break; + case '2': bearing = (bearing*10) + 2; exponentSet?exponent++:true; break; + case '3': bearing = (bearing*10) + 3; exponentSet?exponent++:true; break; + case '4': bearing = (bearing*10) + 4; exponentSet?exponent++:true; break; + case '5': bearing = (bearing*10) + 5; exponentSet?exponent++:true; break; + case '6': bearing = (bearing*10) + 6; exponentSet?exponent++:true; break; + case '7': bearing = (bearing*10) + 7; exponentSet?exponent++:true; break; + case '8': bearing = (bearing*10) + 8; exponentSet?exponent++:true; break; + case '9': bearing = (bearing*10) + 9; exponentSet?exponent++:true; break; + case '.': case ',': + exponentSet = true; + exponent = 0; // May be: N36.513679 (not right, but it'll do) + break; + case '+': + if (i>0) return false; // Sign only at start + negativeBearing = false; + break; + case '-': + if (i>0) return false; // Sign only at start + negativeBearing = true; + break; + case 'n': case 'N': compass = 'N'; exponentSet = true; break; // Can support 36N513679 (not right, but it'll do) + case 'e': case 'E': compass = 'E'; exponentSet = true; break; + case 's': case 'S': compass = 'S'; exponentSet = true; break; + case 'w': case 'W': compass = 'W'; exponentSet = true; break; + case ' ': /* Exit */ + case '\0': /* Exit */ + /* Fail, if the compass has not been set */ + if (compass == 'X') return false; + + /* Place decimal point in bearing */ + if (exponentSet && exponent > 0) bearing = bearing / pow (10, (double) exponent); + + /* Fix-up bearing so that it is in range zero to just under 360 */ + bearing = revolution (bearing); + bearing = negativeBearing ? 360 - bearing : bearing; + + /* Fix-up bearing to Northings or Eastings only */ + if (compass == 'S') { bearing = 360 - bearing; compass = 'N'; } + else if (compass == 'W') { bearing = 360 - bearing; compass = 'E'; } + + /* It's almost done, assign bearing to appropriate global */ + if (compass == 'N') pRun->latitude = fixLatitude (bearing); + else if (compass == 'E') pRun->longitude = fixLongitude (bearing); + else return false; + return true; /* All done */ + break; + default: + return false; + } + } + return false; /* Shouldn't get to here */ + } + + static bool isOffset (runStruct *pRun, const char *pArg) + { int colon = 0, number0 = 0, number1 = 0, number2 = 0; + bool negativeOffset = false; + double returnOffset = 0.0; + + for (int i=0; ; i++) + { switch (pArg[i]) + { + case '0': number0 = (number0*10) + 0; break; + case '1': number0 = (number0*10) + 1; break; + case '2': number0 = (number0*10) + 2; break; + case '3': number0 = (number0*10) + 3; break; + case '4': number0 = (number0*10) + 4; break; + case '5': number0 = (number0*10) + 5; break; + case '6': number0 = (number0*10) + 6; break; + case '7': number0 = (number0*10) + 7; break; + case '8': number0 = (number0*10) + 8; break; + case '9': number0 = (number0*10) + 9; break; + case ':': + number2 = number1; + number1 = number0; + number0 = 0; + colon++; + break; + case '+': + break; + case '-': + if (i>0) return false; // Sign only at start + negativeOffset = true; + break; + case '\0': /* Exit */ + if (colon==0) returnOffset = number0/60.0; + else if (colon==1) returnOffset = number1 + number0/60.0; + else if (colon==2) returnOffset = number2 + number1/60.0 + number0/3600.0; + else return false; + if (negativeOffset) { returnOffset = -returnOffset; } + pRun->offsetHour = returnOffset; + return true; /* <-- Hopefully, exit here <-- */ + break; + default: + return false; + } + } + return false; /* Shouldn't get here */ + } + + /* + ** time_t converted to struct tm. Using GMT (UTC) time. + */ + void myUtcTime (const time_t *pTimet, struct tm *pTm) + { + struct tm *tms = gmtime(pTimet); + + if (tms != NULL) { + *pTm = *tms; + } else { + perror("could not convert time to UTC"); + exit(EXIT_ERROR); + } + } + + /* + ** time_t converted to struct tm. Using local time. + */ + void myLocalTime (const time_t *pTimet, struct tm *pTm) + { + struct tm *tms = localtime(pTimet); + if (tms != NULL) { + *pTm = *tms; + } else { + perror("could not convert time to local time"); + exit (EXIT_ERROR); + } + } + + /* + ** A "struct tm" time can be different from UTC because of TimeZone + ** or Daylight Savings. This function gives the difference - unit: hours. + ** + ** Usage: + ** Add the UTC bias to convert from local-time to UTC. + */ + static double getUtcBiasHours (const time_t *pTimet) + { + struct tm utcTm; + double utcBiasHours = 0.0; + + // Populate "struct tm" with UTC data for the given day + myUtcTime (pTimet, &utcTm); + + char buffer[80]; + signed long int tmpLong = 0; + + mktime(&utcTm); // Let "mktime()" do its magic + + strftime (buffer, 80, "%z", &utcTm); + + if (strlen (buffer) > 0 && myIsNumber (buffer)) { + tmpLong = atol (buffer); + utcBiasHours = (int)(tmpLong/100 + (tmpLong%100)/60.0); + } + + return utcBiasHours; + } + + /* + ** Debug: What's the time (include timezone)? + */ + static void myDebugTime (const char * pTitleChar, const time_t *pTimet) + { if (pRun->debug == ONOFF_ON) + { struct tm tmpLocalTm, tmpUtcTm; + char utcBuffer [80]; + char localBuffer [80]; + + // Convert current time to struct tm for UTC and local timezone + myLocalTime (pTimet, &tmpLocalTm); + myUtcTime (pTimet, &tmpUtcTm); + + strftime ( utcBuffer, 80, "%c %Z", &tmpUtcTm); + printf ("Debug: %s utcTm: %s\n", pTitleChar, utcBuffer); + strftime (localBuffer, 80, "%c %Z", &tmpLocalTm); + printf ("Debug: %s localTm: %s\n", pTitleChar, localBuffer); + + // Difference between UTC and local TZ + strftime ( utcBuffer, 80, "%Z", &tmpUtcTm); + strftime (localBuffer, 80, "%Z", &tmpLocalTm); + printf ("Debug: %s UTC bias (add to %s to get %s) hours: %f\n", pTitleChar, utcBuffer, localBuffer, getUtcBiasHours (pTimet)); + } + } + + /* + ** Return time_t of midnight UTC on the day given + ** In effect, this function is going to shave upto 24 hours off a time + ** returning 00:00 UTC on the day given. + */ + static time_t getMidnightUTC (const time_t *pTimet, const runStruct *pRun) + { struct tm tmpTm; + + // Convert target "struct tm" to time_t. It'll be set to midnight local time, on the target day. + myUtcTime (pTimet, &tmpTm); + + // Set to the start of the day + tmpTm.tm_hour = 0; + tmpTm.tm_min = 0; + tmpTm.tm_sec = 0; + + // Fiddle with other "struct tm" fields to get things right + tmpTm.tm_wday = 0; // mktime will ignore this when calculating time_t as it contradicts days and months + tmpTm.tm_yday = 0; // mktime will ignore this when calculating time_t as it contradicts days and months + tmpTm.tm_isdst = -1; // -1 means: mktime() must work it out. 0=DST not in effect. 1=DST in effect. (Daylight Savings) + + // Shave off (add) UTC offset, so that time_t is converted from midnight local-time to midnight UTC on the target day + tmpTm.tm_sec += myRound (pRun->utcBiasHours * 3600.0); + + // Let mktime() do it's magic + return mktime (&tmpTm); + } + + /* + ** A utility that helps determine if the given targetStruct is DAY or NIGHT + ** This isn't the end of the matter, as DAY from yesterday or tomorrow + ** could slip past midnight into the target day. Near the dateline + ** a UTC day features midday NIGHT. The sun is high near midnight UTC. + ** + ** THE TARGET DATE MUST BE THE CURRENT DATE (on 1st call, as this function iterates) + */ + OnOff isDay (const runStruct *pRun) + { // If the time is before sunrise or after sunset, I need to know that + // we're not in the daylight of either the neighbouring days. + + targetStruct yesterday; + yesterday.twilightAngle = pRun->twilightAngle; + yesterday.daysSince2000 = pRun->now2000 - 1; + + targetStruct today; + today.twilightAngle = pRun->twilightAngle; + today.daysSince2000 = pRun->now2000; + + targetStruct tomorrow; + tomorrow.twilightAngle = pRun->twilightAngle; + tomorrow.daysSince2000 = pRun->now2000 + 1; + + sunriset (pRun, &yesterday); + sunriset (pRun, &today); + sunriset (pRun, &tomorrow); + + yesterday.southHourUTC -= 24.0; + tomorrow.southHourUTC += 24.0; + + // Get current time (hours from UTC midnight of current day). + // Difftime() returns "seconds", we want "hours". + time_t midnightUTC = getMidnightUTC (&pRun->nowTimet, pRun); + double nowHourUTC = difftime (pRun->nowTimet, midnightUTC) / (3600.0); + + // Get the time (0-24) of sunrise and set, of the three days + double riseHourUTCYesterday = getOffsetRiseHourUTC (pRun, &yesterday); + double setHourUTCYesterday = getOffsetSetHourUTC (pRun, &yesterday); + double riseHourUTCToday = getOffsetRiseHourUTC (pRun, &today); + double setHourUTCToday = getOffsetSetHourUTC (pRun, &today); + double riseHourUTCTomorrow = getOffsetRiseHourUTC (pRun, &tomorrow); + double setHourUTCTomorrow = getOffsetSetHourUTC (pRun, &tomorrow); + + // Figure out if we're between sunrise and sunset (with offset) of any of the three days + return + ( (nowHourUTC >= riseHourUTCYesterday && nowHourUTC <= setHourUTCYesterday) + || (nowHourUTC >= riseHourUTCToday && nowHourUTC <= setHourUTCToday ) + || (nowHourUTC >= riseHourUTCTomorrow && nowHourUTC <= setHourUTCTomorrow ) + ) ? ONOFF_ON : ONOFF_OFF; + } + + /* + ** + ** >>>>> main() <<<<< + ** + */ + + int main (int argc, char *argv[]) + { + pRun = &gRun; + + // Set Default values + pRun->latitude = DEFAULT_LATITUDE; + pRun->longitude = DEFAULT_LONGITUDE; + pRun->offsetHour = 0.0; + pRun->utcBiasHours = 0.0; + pRun->functionVersion = ONOFF_OFF; + pRun->functionUsage = ONOFF_OFF; + pRun->functionWait = ONOFF_OFF; + pRun->functionPoll = ONOFF_OFF; + pRun->functionReport = ONOFF_OFF; + pRun->functionList = ONOFF_OFF; + pRun->debug = ONOFF_OFF; + pRun->reportSunrise = ONOFF_OFF; + pRun->reportSunset = ONOFF_OFF; + pRun->utc = ONOFF_OFF; + + pRun->twilightAngle = TWILIGHT_ANGLE_DAYLIGHT; + + // For target year + int yearInt = NOT_SET; + int monInt = NOT_SET; + int mdayInt = NOT_SET; + + // Return code + int exitCode = EXIT_OK; + + // + // DO NOT PUT CODE BEFORE "debug" ARGUMENT IS KNOWN (UNTIL AFTER COMMAND LINE PARSED) + // + + /* + ** + ** Parse command line arguments + ** + */ + + // Change to all lowercase, just to make life easier ... + stringsToLower (argc, argv); + + // Look for debug being activated ... + for (int i=1; i < argc; i++) if (!strcmp (argv [i], "debug")) pRun->debug = ONOFF_ON; + + // For each argument + for (int i=1; i < argc; i++) + { + char *arg = argv[i]; + + // Echo argument, if in debug + if (pRun->debug == ONOFF_ON) printf ("Debug: argv[%d]: >%s<\n", i, arg); + + // Strip any hyphen from arguments, but not negative signs of numbers + if (arg[0] == '-' && arg[1] != '\0' && !isdigit(arg[1])) memmove(arg, arg + 1, sizeof arg - 1); + + // Normal help or version info + if (!strcmp (arg, "v") || + !strcmp (arg, "-V") || + !strcmp (arg, "-v") || + !strcmp (arg, "--version") || + !strcmp (arg, "version")) pRun->functionVersion = ONOFF_ON; + else if (!strcmp (arg, "nv") || + !strcmp (arg, "noversion")) pRun->functionVersion = ONOFF_OFF; + + else if (!strcmp (arg, "?") || + !strcmp (arg, "usage") || + !strcmp (arg, "--help") || + !strcmp (arg, "h") || + !strcmp (arg, "-help") || + !strcmp (arg, "help")) pRun->functionUsage = ONOFF_ON; + else if (!strcmp (arg, "nh" ) || + !strcmp (arg, "nousage") || + !strcmp (arg, "nohelp")) pRun->functionUsage = ONOFF_OFF; + + // Major Options + else if (!strcmp (arg, "wait")) pRun->functionWait = ONOFF_ON; + else if (!strcmp (arg, "poll")) pRun->functionPoll = ONOFF_ON; + else if (!strcmp (arg, "report")) pRun->functionReport = ONOFF_ON; + else if (!strcmp (arg, "list")) { // List should have a parameter attached + pRun->functionList = ONOFF_ON; + if (i+1<argc && myIsSignedNumber (argv[i+1])) + pRun->listDays = atoi (argv [++i]); // Note: ++i + else + pRun->listDays = DEFAULT_LIST; + } + + // Minor Options + + // Print output in GMT or local-time + else if (!strcmp (arg, "gmt") || + !strcmp (arg, "utc")) pRun->utc = ONOFF_ON; + else if (!strcmp (arg, "nogmt") || + !strcmp (arg, "noutc")) pRun->utc = ONOFF_OFF; + + // Debug mode + else if (!strcmp (arg, "debug") || + !strcmp (arg, "--debug") || + !strcmp (arg, "--verbose") || + !strcmp (arg, "-v")) pRun->debug = ONOFF_ON; + else if (!strcmp (arg, "nodebug")) pRun->debug = ONOFF_OFF; + + // Poll. Is it DAY or NIGHT? + else if (!strcmp (arg, "e") || + !strcmp (arg, "er") || + !strcmp (arg, "exit") || + !strcmp (arg, "poll") || + !strcmp (arg, "exitreport")) pRun->functionPoll = ONOFF_ON; + else if (!strcmp (arg, "ne") || + !strcmp (arg, "ner") || + !strcmp (arg, "noexit") || + !strcmp (arg, "nopoll") || + !strcmp (arg, "noexitreport")) pRun->functionPoll = ONOFF_OFF; + + // Specify twilight angle + else if (!strcmp (arg, "sun") || + !strcmp (arg, "day") || + !strcmp (arg, "light") || + !strcmp (arg, "normal") || + !strcmp (arg, "visible") || + !strcmp (arg, "daylight")) pRun->twilightAngle = TWILIGHT_ANGLE_DAYLIGHT; + else if (!strcmp (arg, "civil") || + !strcmp (arg, "civ")) pRun->twilightAngle = TWILIGHT_ANGLE_CIVIL; + else if (!strcmp (arg, "nautical") || + !strcmp (arg, "nau") || + !strcmp (arg, "naut")) pRun->twilightAngle = TWILIGHT_ANGLE_NAUTICAL; + else if (!strcmp (arg, "astronomical") || + !strcmp (arg, "ast") || + !strcmp (arg, "astr") || + !strcmp (arg, "astro")) pRun->twilightAngle = TWILIGHT_ANGLE_ASTRONOMICAL; + else if (!strcmp (arg, "a") || + !strcmp (arg, "angle") || + !strcmp (arg, "twilightangle") || + !strcmp (arg, "twilight")) { if (i+1<argc && myIsSignedFloat (argv[i+1])) + pRun->twilightAngle = atof (argv [++i]); // Note: "++i" + else + pRun->twilightAngle = TWILIGHT_ANGLE_DAYLIGHT; + } + + // Specify target date (default is today) + else if (!strcmp (arg, "y") && i+1<argc && myIsNumber (argv[i+1])) yearInt = atoi (argv [++i]); // Note: "++i" + else if (!strcmp (arg, "m") && i+1<argc && myIsNumber (argv[i+1])) monInt = atoi (argv [++i]); // Note: "++i" + else if (!strcmp (arg, "d") && i+1<argc && myIsNumber (argv[i+1])) mdayInt = atoi (argv [++i]); // Note: "++i" + + // Specify fixed duration offset + else if (!strcmp (arg, "o") || + !strcmp (arg, "off") || + !strcmp (arg, "offset")) { if (i+1<argc && isOffset (pRun, argv[i+1])) { ++i; } /* Functionality in "isOffset()" */ + } + + // Specify if sunrise and/or sunset timings a required. + else if (!strcmp (arg, "sunrise") || + !strcmp (arg, "rise") || + !strcmp (arg, "dawn") || + !strcmp (arg, "sunup") || + !strcmp (arg, "up")) pRun->reportSunrise = ONOFF_ON; + else if (!strcmp (arg, "sunset") || + !strcmp (arg, "set") || + !strcmp (arg, "dusk") || + !strcmp (arg, "sundown") || + !strcmp (arg, "down")) pRun->reportSunset = ONOFF_ON; + + // Specify latitude and longitude - quite complex, so I've handled it elsewhere + else if (isBearing (pRun, arg)) {} /* Functionality in "isBearing()" */ + + // Don't know what in on the command line, so complain. + else printf ("Error: Unknown command-line argument: %s\n", arg); + } + + + /* + ** + ** Analyse command line, check for errors and fill in gaps + ** + */ + + if (pRun->debug == ONOFF_ON) + { if (pRun->utc == ONOFF_ON) + printf ("Debug: All output to use UTC.\n"); + else + printf ("Debug: All output to use local timezone (nogmt).\n"); + } + + + /* + ** Get: current time (time_t is UTC, always) and bias of local-time from UTC + */ + + time (&pRun->nowTimet); + if (pRun->debug == ONOFF_ON) myDebugTime ("Now", &pRun->nowTimet); + + pRun->utcBiasHours = getUtcBiasHours (&pRun->nowTimet); + if (pRun->debug == ONOFF_ON) printf ("Debug: UTC Bias (hours): %f\n", pRun->utcBiasHours); + + pRun->now2000 = daysSince2000 (&pRun->nowTimet); + if (pRun->debug == ONOFF_ON) printf ("Debug: Now: Days since 2000: %lu\n", pRun->now2000); + + + /* + ** Get: Target Date + */ + + { struct tm targetTm; + + // Populate targetTm :- + // Get the target day (as "struct tm") for "now" - the default + // I'll get the local-time day, as it'll make sense with the user, unless UTC was asked for + // + + if (pRun->utc == ONOFF_ON) + myUtcTime (&pRun->nowTimet, &targetTm); // User wants UTC + else + myLocalTime (&pRun->nowTimet, &targetTm); // User gets local timezone + + // + // Parse "target" year, month and day [adjust target] + // + + if (yearInt != NOT_SET) + { if (yearInt < 0 || yearInt > 99) + { printf ("Error: \"Year\" must be between 0 and 99: %u\n", yearInt); + exit (EXIT_ERROR); + } + targetTm.tm_year = yearInt + 100; + } + if (pRun->debug == ONOFF_ON) printf ("Debug: Target year set to: %u\n", targetTm.tm_year); + + if (monInt != NOT_SET) + { if (monInt < 1 || monInt > 12) + { printf ("Error: \"Month\" must be between 1 and 12: %u\n", monInt); + exit (EXIT_ERROR); + } + targetTm.tm_mon = monInt-1; // We need month 0 to 11, not 1 to 12 + } + if (pRun->debug == ONOFF_ON) printf ("Debug: Target mon set to: %u\n", targetTm.tm_mon); + + if (mdayInt != NOT_SET) + { if (mdayInt < 1 || mdayInt > 31) + { printf ("Error: \"Day of month\" must be between 1 and 31: %u\n", mdayInt); + exit (EXIT_ERROR); + } + targetTm.tm_mday = mdayInt; + } + if (pRun->debug == ONOFF_ON) printf ("Debug: Target mday set to: %u\n", targetTm.tm_mday); + + // Set target time to the start of the UTC day + targetTm.tm_hour = 0; + targetTm.tm_min = 0; + targetTm.tm_sec = 0; + + // Fiddle with other "struct tm" fields to get things right + targetTm.tm_wday = 0; // mktime will ignore this when calculating time_t as it contradicts days and months + targetTm.tm_yday = 0; // mktime will ignore this when calculating time_t as it contradicts days and months + targetTm.tm_isdst = -1; // -1 means: mktime() must work it out. 0=DST not in effect. 1=DST in effect. (Daylight Savings) + + // Convert target "struct tm" to time_t. It'll be set to midnight local time, on the target day. + pRun->targetTimet = mktime (&targetTm); + + // Shave off (add) UTC offset, so that time_t is converted from midnight local-time to midnight UTC on the target day + targetTm.tm_sec += myRound (pRun->utcBiasHours * 60.0 * 60.0); + + // Adjustment below suggested by Phos Quartz on sourceforge.net to + // address the case when invocation time and target time are not + // in the same timezone (i.e. standard time vs daylight time) + // see https://sourceforge.net/p/sunwait4windows/discussion/general/thread/98fc17dd5f/ + struct tm localTm; + myLocalTime (&pRun->nowTimet, &localTm); + int isdst = localTm.tm_isdst; + targetTm.tm_isdst = isdst; + + // All done + pRun->targetTimet = mktime (&targetTm); // <<<<<< The important bit done <<< targetTimet is set to midnight UTC + + if (pRun->debug == ONOFF_ON) myDebugTime ("Target", &pRun->targetTimet); + } + + pRun->target2000 = daysSince2000 (&pRun->targetTimet); + if (pRun->debug == ONOFF_ON) printf ("Debug: Target: Days since 2000: %lu\n", pRun->target2000); + + /* + ** Check: Latitude and Longitude + */ + + if (pRun->latitude == NOT_SET) + { if (pRun->debug == ONOFF_ON) printf ("Debug: latitude not set. Default applied.\n"); + pRun->latitude = DEFAULT_LATITUDE; + } + + if (pRun->longitude == NOT_SET) + { if (pRun->debug == ONOFF_ON) printf ("Debug: longitude not set. Default applied.\n"); + pRun->longitude = DEFAULT_LONGITUDE; + } + + // /* Co-ordinates must be in 0 to 360 range */ // IFC 2014-12-02: Removed as done in isBearing() + // pRun->latitude = revolution (pRun->latitude); // IFC 2014-12-02: Removed as done in isBearing() + // pRun->longitude = revolution (pRun->longitude); // IFC 2014-12-02: Removed as done in isBearing() + + if (pRun->debug == ONOFF_ON) + { printf ("Debug: Co-ordinates - Latitude: %fN\n", pRun->latitude); + printf ("Debug: Co-ordinates - Longitude: %fE\n", pRun->longitude); + } + + /* + ** Check: Twilight Angle + */ + + if (pRun->twilightAngle == NOT_SET) + { if (pRun->debug == ONOFF_ON) printf ("Debug: twilight angle not set. Default: daylight.\n"); + pRun->twilightAngle = TWILIGHT_ANGLE_DAYLIGHT; + } + + if (pRun->twilightAngle <= -90 || pRun->twilightAngle >= 90) + { + printf ("Error: Twilight angle must be between -90 and +90 (-ve = below horizon), your setting: %f\n", pRun->twilightAngle); + pRun->twilightAngle = TWILIGHT_ANGLE_DAYLIGHT; + } + + if (pRun->debug == ONOFF_ON) + { if (pRun->twilightAngle == TWILIGHT_ANGLE_DAYLIGHT) printf ("Debug: Twilight - Daylight\n"); + else if (pRun->twilightAngle == TWILIGHT_ANGLE_CIVIL) printf ("Debug: Twilight - Civil\n"); + else if (pRun->twilightAngle == TWILIGHT_ANGLE_NAUTICAL) printf ("Debug: Twilight - Nautical\n"); + else if (pRun->twilightAngle == TWILIGHT_ANGLE_ASTRONOMICAL) printf ("Debug: Twilight - Astronomical\n"); + else printf ("Debug: Twilight - Custom angle (degrees): %f\n", pRun->twilightAngle); + } + + /* + ** Check: Offset + */ + + if (pRun->debug == ONOFF_ON) printf ("Debug: User specified offset (hours): %f\n", pRun->offsetHour); + + + /* + ** Check: Major-option or Function + */ + + // IF no function requested THEN default to "usage" + if + ( pRun->functionList == ONOFF_OFF + && pRun->functionPoll == ONOFF_OFF + && pRun->functionUsage == ONOFF_OFF + && pRun->functionVersion == ONOFF_OFF + && pRun->functionWait == ONOFF_OFF + && pRun->functionReport == ONOFF_OFF + ) pRun->functionUsage = ONOFF_ON; + + /* + ** Check: Sunrise or sunset. IF neither set THEN set both + */ + + if (pRun->reportSunrise == ONOFF_OFF && pRun->reportSunset == ONOFF_OFF) + { pRun->reportSunrise = ONOFF_ON; + pRun->reportSunset = ONOFF_ON; + } + + /* + ** OK - we're all done figuring out what to do - let's do it + */ + + if (pRun->functionVersion == ONOFF_ON) + { if (pRun->debug == ONOFF_ON) printf ("Debug: Function selected: Version\n"); + print_version (); + exitCode = EXIT_OK; + } + + if (pRun->functionUsage == ONOFF_ON) + { if (pRun->debug == ONOFF_ON) printf ("Debug: Function selected: Usage\n"); + print_usage (); + exitCode = EXIT_OK; + } + + if (pRun->functionReport == ONOFF_ON) + { if (pRun->debug == ONOFF_ON) printf ("Debug: Function selected: Report\n"); + generate_report (pRun); + exitCode = EXIT_OK; + } + + if (pRun->functionList == ONOFF_ON) + { if (pRun->debug == ONOFF_ON) printf ("Debug: Function selected: List\n"); + print_list (pRun); + exitCode = EXIT_OK; + } + + if (pRun->functionWait == ONOFF_ON) + { if (pRun->debug == ONOFF_ON) printf ("Debug: Function selected: Wait\n"); + exitCode = sunwait (pRun); + } + + if (pRun->functionPoll == ONOFF_ON) + { if (pRun->debug == ONOFF_ON) printf ("Debug: Function selected: Poll\n"); + exitCode = sunpoll (pRun); + if (exitCode == EXIT_DAY) printf ("DAY\n"); + else if (exitCode == EXIT_NIGHT) printf ("NIGHT\n"); + else if (exitCode == EXIT_OK) printf ("OK\n"); + else if (exitCode == EXIT_ERROR) printf ("ERROR\n"); + } + + exit (exitCode); + } + + /* + ** Simply check if we think now/current-time is night OR day (day includes twilight) + */ + inline int sunpoll (const runStruct *pRun) + { + return isDay (pRun) == ONOFF_ON ? EXIT_DAY : EXIT_NIGHT; + } + + /* + ** Wait until sunrise or sunset occurs on the target day. + ** That sounds simple, until you start to consider longitudes near the dateline. + ** Midnight UTC can lands later and later within a local day for large longitudes. + ** Latitudes heading towards the poles can either shrink the day length to nothing or the whole day, depending on the season. + ** A user-specified offset messes around with daylength too. + ** Exit immediately if its a polar day or midnight sun (including offset). + */ + int sunwait (const runStruct *pRun) + { + /* + ** Calculate start/end of twilight for given twilight type/angle. + ** For latitudes near poles, the sun might not pass through specified twilight angle that day. + ** For big longitudes, it's quite likely the sun is up at midnight UTC: this means we have to calculate successive days. + */ + + targetStruct yesterday; + yesterday.twilightAngle = pRun->twilightAngle; + yesterday.daysSince2000 = pRun->target2000 - 1; + + targetStruct today; + today.twilightAngle = pRun->twilightAngle; + today.daysSince2000 = pRun->target2000; + + targetStruct tomorrow; + tomorrow.twilightAngle = pRun->twilightAngle; + tomorrow.daysSince2000 = pRun->target2000 + 1; + + sunriset (pRun, &yesterday); + sunriset (pRun, &today); + sunriset (pRun, &tomorrow); + + yesterday.southHourUTC -= 24; + tomorrow.southHourUTC += 24; + + // Calculate duration (seconds) from "now" to "midnight UTC on the target day". [difftime (end, beginning)] + long waitMidnightUTC = (long) (difftime (pRun->targetTimet, pRun->nowTimet)); + + // Calculate duration to wait for each day's rise and set (seconds) + // (targetTimet is set to midnight on the target day) + long waitRiseYesterday = waitMidnightUTC + (long) ( 3600.0 * getOffsetRiseHourUTC (pRun, &yesterday) ); + long waitSetYesterday = waitMidnightUTC + (long) ( 3600.0 * getOffsetSetHourUTC (pRun, &yesterday) ); + long waitRiseToday = waitMidnightUTC + (long) ( 3600.0 * getOffsetRiseHourUTC (pRun, &today) ); + long waitSetToday = waitMidnightUTC + (long) ( 3600.0 * getOffsetSetHourUTC (pRun, &today) ); + long waitRiseTomorrow = waitMidnightUTC + (long) ( 3600.0 * getOffsetRiseHourUTC (pRun, &tomorrow) ); + long waitSetTomorrow = waitMidnightUTC + (long) ( 3600.0 * getOffsetSetHourUTC (pRun, &tomorrow) ); + + // Determine next sunrise and sunset + // (we may be in DAY, so the next event is sunset - followed by sunrise) + + long waitRiseSeconds = 0; + long waitSetSeconds = 0; + + if (waitRiseYesterday > 0) { waitRiseSeconds = waitRiseYesterday; waitSetSeconds = waitSetYesterday; } + else if (waitSetYesterday > 0) { waitRiseSeconds = waitRiseToday; waitSetSeconds = waitSetYesterday; } + else if (waitRiseToday > 0) { waitRiseSeconds = waitRiseToday; waitSetSeconds = waitSetToday; } + else if (waitSetToday > 0) { waitRiseSeconds = waitRiseTomorrow; waitSetSeconds = waitSetToday; } + else if (waitRiseTomorrow > 0) { waitRiseSeconds = waitRiseTomorrow; waitSetSeconds = waitSetTomorrow; } + else if (waitSetTomorrow > 0) { waitRiseSeconds = 0; waitSetSeconds = waitSetTomorrow; } + + // Is it currently DAY or NIGHT? + + OnOff isDay = ONOFF_OFF; + + if (waitRiseYesterday > 0) { isDay = ONOFF_OFF; } + else if (waitSetYesterday > 0) { isDay = ONOFF_ON; } + else if (waitRiseToday > 0) { isDay = ONOFF_OFF; } + else if (waitSetToday > 0) { isDay = ONOFF_ON; } + else if (waitRiseTomorrow > 0) { isDay = ONOFF_OFF; } + else if (waitSetTomorrow > 0) { isDay = ONOFF_ON; } + + // Determine if the day is "normal" (where the rises and sets) or "polar" ("midnight sun" or "polar night") + + bool exitPolar = false; + + if (waitSetYesterday > 0) { double diurnalArc = diurnalArcWithOffset (pRun, &yesterday); exitPolar = diurnalArc <= 0.0 || diurnalArc >= 24.0; } + else if (waitSetToday > 0) { double diurnalArc = diurnalArcWithOffset (pRun, &today); exitPolar = diurnalArc <= 0.0 || diurnalArc >= 24.0; } + else { double diurnalArc = diurnalArcWithOffset (pRun, &tomorrow); exitPolar = diurnalArc <= 0.0 || diurnalArc >= 24.0; } + + if (exitPolar) + { if (pRun->debug == ONOFF_ON) printf ("Debug: Polar region or large offset: No sunrise today, there's nothing to wait for!\n"); + return EXIT_ERROR; + } + + // Get next rise or set time UNLESS the opposite event happens first (unless less than 6 hours to required event) + // IF both rise and set requested THEN wait for whichever is next + + long waitSeconds = 0; + + if (pRun->reportSunrise == ONOFF_ON && pRun->reportSunset == ONOFF_OFF) + { if (isDay == ONOFF_OFF || waitRiseSeconds < 6*60*60) waitSeconds = waitRiseSeconds; } + else if (pRun->reportSunrise == ONOFF_OFF && pRun->reportSunset == ONOFF_ON) + { if (isDay == ONOFF_ON || waitSetSeconds < 6*60*60) waitSeconds = waitSetSeconds; } + else + { waitSeconds = waitRiseSeconds < waitSetSeconds ? waitRiseSeconds : waitSetSeconds; } + + // Don't wait if event has passed (or next going to occur soon [6hrs]) + if (waitSeconds <= 0) + { if (pRun->debug == ONOFF_ON) printf ("Debug: Event already passed today, can't wait for that!\n"); + return EXIT_ERROR; + } + + // + // In debug mode, we don't want to wait for sunrise or sunset. Wait a minute instead. + // + + if (pRun->debug == ONOFF_ON) + { printf("Debug: Wait reduced from %li to 10 seconds.\n", waitSeconds); + waitSeconds = 10; + } + else if (pRun->functionPoll == ONOFF_ON) waitSeconds += 60; // Make more sure that a subsequent POLL works properly (wink ;-) + + /* + ** Sleep (wait) until the event is expected + */ + sleepSeconds(waitSeconds); + + return EXIT_OK; + }
• sunwait.cpp (deleted)
  • @@ -1,1149 +0,0 @@
    - // sunwait.cpp : Defines the entry point for the console application. - // - - // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv CHANGE ME - // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv CHANGE ME - const double VERSION=0.91; // <<<<<<<<< CHANGE ME - // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ CHANGE ME - // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ CHANGE ME - - /* copyright (c) 2000,2004,2022 Daniel Risacher */ - /* minor changes courtesy of Dr. David M. MacMillan */ - /* major changes courtesy of Ian Craig (2012-13) */ - /* Licensed under the Gnu General Public License */ - - // Who When Ver What - // IFC 2013-07-13 0.4 Working version of "sunwait", ported to Windows. - // IFC 2014-12-01 0.5 The linux port was not working - the windows sleep is for seconds, the linux is miliseconds. - // I'm porting my home power control to Linux, so I've reworked the whole program to suit. - // IFC 2014-12-08 0.6 Add timezone handling for output - if required - // IFC 2015-04-29 0.7 Timezone and DST fixes - and for date line timings - // IFC 2015-05-27 0.8 Resolve 'dodgy day' and cleanup - // TLJ 2020-10-03 0.9 Fix build on osx - // DRR 2022-09-16 0.91 Fix build with modern GCC - // - - #include <stdio.h> - #include <stdlib.h> - #include <iostream> - #include <time.h> - #include <cstring> - #include <math.h> - - // Windows - #if defined _WIN32 || defined _WIN64 - #include <windows.h> - #endif - - // Linux - #if defined __linux__ || defined __APPLE__ - #include <unistd.h> - #endif - - #include "sunwait.h" - #include "sunriset.h" - #include "print.h" - - using namespace std; - - - /* - ** Define global: - ** 'runStruct' structure allows pretty much everything to be carted simply around functions. - ** 'targetStruct' structure is the interface to the sunrise calcs. Compact, and allows multi-results to be used. - ** It can be a bit naughty on side-effects, so I use 'const' where-ever I can. - */ - - runStruct gRun; - runStruct *pRun; - - void print_version () - { - printf ("Sunwait for Windows. Version %f (IFC).\n", VERSION); - printf ("Code Contributors: P.Schlyter, D.Risacher, D.MacMillan and I.Craig.\n"); - printf ("\n"); - printf (" Sunset is the instant at which the upper edge of the Sun disappears below the horizon.\n"); - printf (" Civil twilight is the period from sunset until the geometric centre of the sun is 6° below the horizon.\n"); - printf (" Nautical twilight is the period when the geometric centre of the sun is between 6° and 12° below the horizon.\n"); - printf (" Astronomical twilight is the period when the geometric centre of the sun is between 12° and 18° below the horizon.\n"); - printf (" Night is period when the geometric center of the sun falls 18° below the horizon.\n"); - - } - - /* - ** It's very useful to have this here - */ - void print_usage () - { printf ("Calculate sunrise and sunset times for the current or targetted day.\n"); - printf ("The times can be adjusted either for twilight or fixed durations.\n"); - printf ("\n"); - printf ("The program can either: wait for sunrise or sunset (function: wait),\n"); - printf (" or return the time (GMT or local) the event occurs (function: list),\n"); - printf (" or report the day length and twilight timings (function: report),\n"); - printf (" or simply report if it is DAY or NIGHT (function: poll).\n"); - printf ("\n"); - printf ("You should specify the latitude and longitude of your target location.\n"); - printf ("\n"); - printf ("\n"); - printf ("Usage: sunwait [major options] [minor options] [twilight type] [rise|set] [offset] [latitude] [longitude]\n"); - printf ("\n"); - printf ("Major options, either:\n"); - printf (" poll Returns immediately indicating DAY or NIGHT. See 'program exit codes'. Default.\n"); - printf (" wait Sleep until specified event occurs. Else exit immediate.\n"); - printf (" list [X] Report twilight times for next 'X' days (inclusive). Default: %u.\n", DEFAULT_LIST); - printf (" report Generate a report about the days sunrise and sunset timings.\n"); - printf ("\n"); - printf ("Minor options, any of:\n"); - printf (" [no]debug Print extra info and returns in one minute. Default: nodebug.\n"); - printf (" [no]version Print the version number. Default: noversion.\n"); - printf (" [no]help Print this help. Default: nohelp.\n"); - printf (" [no]gmt Print times in GMT or local-time. Default: nogmt.\n"); - printf ("\n"); - printf ("Twilight types, either:\n"); - printf (" daylight Top of sun just below the horizon. Default.\n"); - printf (" civil Civil Twilight. -6 degrees below horizon.\n"); - printf (" nautical Nautical twilight. -12 degrees below horizon.\n"); - printf (" astronomical Astronomical twilight. -18 degrees below horizon.\n"); - printf (" angle [X.XX] User-specified twilight-angle (degrees). Default: 0.\n"); - printf ("\n"); - printf ("Sunrise/sunset. Only useful with major-options: 'wait' and 'list'. Any of: (default: both)\n"); - printf (" rise Wait for the sun to rise past specified twilight & offset.\n"); - printf (" set Wait for the sun to set past specified twilight & offset.\n"); - printf ("\n"); - printf ("Offset:\n"); - printf (" offset [MM|HH:MM] Time interval (+ve towards noon) to adjust twilight calculation.\n"); - printf ("\n"); - printf ("Target date. Only useful with major-options: 'report' or 'list'. Default: today\n"); - printf (" d [DD] Set the target Day-of-Month to calculate for. 1 to 31.\n"); - printf (" m [MM] Set the target Month to calculate for. 1 to 12.\n"); - printf (" y [YYYY] Set the target Year to calculate for. 2000 to 2099.\n"); - printf ("\n"); - printf ("latitude/longitude coordinates: floating-point degrees, with [NESW] appended. Default: Bingham, England.\n"); - printf ("\n"); - printf ("Exit (return) codes:\n"); - printf (" %1d OK: exit from 'wait' or 'list' only.\n", EXIT_OK); - printf (" %1d Error.\n", EXIT_ERROR); - printf (" %1d Exit from 'poll': it is DAY or twilight.\n", EXIT_DAY); - printf (" %1d Exit from 'poll': it is NIGHT (after twilight).\n", EXIT_NIGHT); - printf ("\n"); - printf ("Example 1: sunwait wait rise offset -1:15:10 51.477932N 0.000000E\n"); - printf ("Wait until 1 hour 15 minutes 10 secs before the sun rises in Greenwich, London.\n"); - printf ("\n"); - printf ("Example 2: sunwait list 7 civil 55.752163N 37.617524E\n"); - printf ("List civil sunrise and sunset times for today and next 6 days. Moscow.\n"); - printf ("\n"); - printf ("Example 3: sunwait poll exit angle 10 54.897786N -1.517536E\n"); - printf ("Indicate by program exit-code if is Day or Night using a custom twilight angle of 10 degrees above horizon. Washington, UK.\n"); - printf ("\n"); - printf ("Example 4: sunwait list 7 gmt sunrise angle 3\n"); - printf ("List next 7 days sunrise times, custom +3 degree twilight angle, default location.\n"); - printf ("Uses GMT; as any change in daylight saving over the specified period is not considered.\n"); - printf ("\n"); - printf ("Note that program uses C library functions to determine time and localtime.\n"); - printf ("Error for timings are estimated at: +/- 4 minutes.\n"); - printf ("\n"); - } - - void myToLower (char *arg) - { for (unsigned int i=0; i < strlen (arg); i++) - arg[i] = tolower (arg[i]); - } - - void myToLower (const int argc, char *argv[]) - { for (int i=1; i < argc; i++) - myToLower (argv [i]); - } - - boolean myIsNumber (const char *arg) - { bool digitSet = false; - for (int i=0; ; i++) - { switch (arg[i]) - { - case '0': - case '1': - case '2': - case '3': - case '4': - case '5': - case '6': - case '7': - case '8': - case '9': digitSet = true; break; - case '-': - case '+': if (digitSet) return false; break; - case '\0': return digitSet; break; // Exit OK - default: return false; // Exit Error - } - } - return false; /* Shouldn't get here */ - } - - boolean myIsSignedNumber (const char *arg) - { bool digitSet = false; - for (int i=0; ; i++) - { switch (arg[i]) - { - case '0': - case '1': - case '2': - case '3': - case '4': - case '5': - case '6': - case '7': - case '8': - case '9': digitSet = true; break; - case '+': - case '-': if (i>0) return false; break; /* Sign only at start */ - case '\0': return digitSet; break; // Exit OK - default: return false; // Exit Error - } - } - return false; /* Shouldn't get here */ - } - - boolean myIsSignedFloat (const char *arg) - { bool digitSet = false; - for (int i=0; ; i++) - { switch (arg[i]) - { - case '0': - case '1': - case '2': - case '3': - case '4': - case '5': - case '6': - case '7': - case '8': - case '9': digitSet = true; break; - case '.': break; /* Can be anywhere (but in front of sign), or not there */ - case '+': - case '-': if (i>0) return false; break; /* Sign only at start */ - case '\0': return digitSet; break; // Exit OK - default: return false; // Exit Error - } - } - return false; /* Shouldn't get here */ - } - - boolean myIsSignedFloat (const char *pArg, double *pDouble) - { double number = 0; - int exponent = 0; - bool negative = false; - bool exponentSet = false; - for (int i=0; ; i++) - { switch (pArg[i]) - { - case '0': number = (number*10) + 0; exponentSet?exponent++:true; break; - case '1': number = (number*10) + 1; exponentSet?exponent++:true; break; - case '2': number = (number*10) + 2; exponentSet?exponent++:true; break; - case '3': number = (number*10) + 3; exponentSet?exponent++:true; break; - case '4': number = (number*10) + 4; exponentSet?exponent++:true; break; - case '5': number = (number*10) + 5; exponentSet?exponent++:true; break; - case '6': number = (number*10) + 6; exponentSet?exponent++:true; break; - case '7': number = (number*10) + 7; exponentSet?exponent++:true; break; - case '8': number = (number*10) + 8; exponentSet?exponent++:true; break; - case '9': number = (number*10) + 9; exponentSet?exponent++:true; break; - case '.': case ',': - exponentSet = true; - exponent = 0; // May be: N36.513679 (not right, but it'll do) - break; - case '+': - if (i>0) return false; // Sign only at start - negative = false; - break; - case '-': - if (i>0) return false; // Sign only at start - negative = true; - break; - case '\0': /* Exit */ - /* Place decimal point in number */ - if (exponentSet && exponent > 0) number = number / pow (10, (double) exponent); - if (negative) number = -number; - *pDouble = number; - return true; /* All done */ - break; - default: - return false; - } - } - return false; /* Shouldn't get to here */ - } - - boolean isBearing (runStruct *pRun, const char *pArg) - { double bearing = 0; - int exponent = 0; - bool negativeBearing = false; - bool exponentSet = false; - char compass = 'X'; - - for (int i=0; ; i++) - { switch (pArg[i]) - { - case '0': bearing = (bearing*10) + 0; exponentSet?exponent++:true; break; - case '1': bearing = (bearing*10) + 1; exponentSet?exponent++:true; break; - case '2': bearing = (bearing*10) + 2; exponentSet?exponent++:true; break; - case '3': bearing = (bearing*10) + 3; exponentSet?exponent++:true; break; - case '4': bearing = (bearing*10) + 4; exponentSet?exponent++:true; break; - case '5': bearing = (bearing*10) + 5; exponentSet?exponent++:true; break; - case '6': bearing = (bearing*10) + 6; exponentSet?exponent++:true; break; - case '7': bearing = (bearing*10) + 7; exponentSet?exponent++:true; break; - case '8': bearing = (bearing*10) + 8; exponentSet?exponent++:true; break; - case '9': bearing = (bearing*10) + 9; exponentSet?exponent++:true; break; - case '.': case ',': - exponentSet = true; - exponent = 0; // May be: N36.513679 (not right, but it'll do) - break; - case '+': - if (i>0) return false; // Sign only at start - negativeBearing = false; - break; - case '-': - if (i>0) return false; // Sign only at start - negativeBearing = true; - break; - case 'n': case 'N': compass = 'N'; exponentSet = true; break; // Can support 36N513679 (not right, but it'll do) - case 'e': case 'E': compass = 'E'; exponentSet = true; break; - case 's': case 'S': compass = 'S'; exponentSet = true; break; - case 'w': case 'W': compass = 'W'; exponentSet = true; break; - case ' ': /* Exit */ - case '\0': /* Exit */ - /* Fail, if the compass has not been set */ - if (compass == 'X') return false; - - /* Place decimal point in bearing */ - if (exponentSet && exponent > 0) bearing = bearing / pow (10, (double) exponent); - - /* Fix-up bearing so that it is in range zero to just under 360 */ - bearing = revolution (bearing); - bearing = negativeBearing ? 360 - bearing : bearing; - - /* Fix-up bearing to Northings or Eastings only */ - if (compass == 'S') { bearing = 360 - bearing; compass = 'N'; } - else if (compass == 'W') { bearing = 360 - bearing; compass = 'E'; } - - /* It's almost done, assign bearing to appropriate global */ - if (compass == 'N') pRun->latitude = fixLatitude (bearing); - else if (compass == 'E') pRun->longitude = fixLongitude (bearing); - else return false; - return true; /* All done */ - break; - default: - return false; - } - } - return false; /* Shouldn't get to here */ - } - - boolean isOffset (runStruct *pRun, const char *pArg) - { int colon = 0, number0 = 0, number1 = 0, number2 = 0; - bool negativeOffset = false; - double returnOffset = 0.0; - - for (int i=0; ; i++) - { switch (pArg[i]) - { - case '0': number0 = (number0*10) + 0; break; - case '1': number0 = (number0*10) + 1; break; - case '2': number0 = (number0*10) + 2; break; - case '3': number0 = (number0*10) + 3; break; - case '4': number0 = (number0*10) + 4; break; - case '5': number0 = (number0*10) + 5; break; - case '6': number0 = (number0*10) + 6; break; - case '7': number0 = (number0*10) + 7; break; - case '8': number0 = (number0*10) + 8; break; - case '9': number0 = (number0*10) + 9; break; - case ':': - number2 = number1; - number1 = number0; - number0 = 0; - colon++; - break; - case '+': - break; - case '-': - if (i>0) return false; // Sign only at start - negativeOffset = true; - break; - case '\0': /* Exit */ - if (colon==0) returnOffset = number0/60.0; - else if (colon==1) returnOffset = number1 + number0/60.0; - else if (colon==2) returnOffset = number2 + number1/60.0 + number0/3600.0; - else return false; - if (negativeOffset) { returnOffset = -returnOffset; } - pRun->offsetHour = returnOffset; - return true; /* <-- Hopefully, exit here <-- */ - break; - default: - return false; - } - } - return false; /* Shouldn't get here */ - } - - - /* - ** time_t converted to struct tm. Using GMT (UTC) time. - */ - void myUtcTime (const time_t *pTimet, struct tm *pTm) - { - /* Windows code: Start */ - #if defined _WIN32 || defined _WIN64 - errno_t err; - err = _gmtime64_s (pTm, pTimet); - if (err) { printf ("Error: Invalid Argument to _gmtime64_s ().\n"); exit (EXIT_ERROR); } - #endif - /* Windows code: End */ - - /* Linux code: Start */ - #if defined __linux__ || defined __APPLE__ - gmtime_r (pTimet, pTm); - #endif - /* Linux code: End */ - } - - /* - ** time_t converted to struct tm. Using local time. - */ - void myLocalTime (const time_t *pTimet, struct tm *pTm) - { - /* Windows code: Start */ - #if defined _WIN32 || defined _WIN64 - errno_t err; - err = _localtime64_s (pTm, pTimet); - if (err) { printf ("Error: Invalid Argument to _gmtime64_s ().\n"); exit (EXIT_ERROR); } - #endif - /* Windows code: End */ - - /* Linux code: Start */ - #if defined __linux__ || defined __APPLE__ - localtime_r (pTimet, pTm); - #endif - /* Linux code: End */ - } - - /* - ** A "struct tm" time can be different from UTC because of TimeZone - ** or Daylight Savings. This function gives the difference - unit: hours. - ** - ** Usage: - ** Add the UTC bias to convert from local-time to UTC. - ** ptrTm is set - */ - double getUtcBiasHours (const time_t *pTimet) - { - struct tm utcTm; - double utcBiasHours = 0.0; - - // Populate "struct tm" with UTC data for the given day - myUtcTime (pTimet, &utcTm); - - /* Windows code: Start */ - #if defined _WIN32 || defined _WIN64 - struct tm utcNoonTm, localNoonTm; - - // Keep to the same day given, but go for noon. Daylight savings changes usually happen in the early hours. - // mktime() changes the values in "struct tm", so I need to use a private one anyway. - utcTm.tm_hour = 12; - utcTm.tm_min = 0; - utcTm.tm_sec = 0; - - // Now convert this time to time_t (which is always, by definition, UTC), - // so I can run both of the two functions I can use that differentiate between timezones, using the same UTC moment. - time_t noonTimet = mktime (&utcTm); // Unfortunately this is noonTimet is local time. It's the best I can do. - // If it was UTC, all locations on earth are within the same day at noon. - // (Because UTC = GMT. Noon GMT +/- 12hrs nestles upto, but not across, the dateline) - // Local-time 'days' (away from GMT) will probably cross the date line. - - myLocalTime (&noonTimet, &localNoonTm); // Generate 'struct tm' for local time - myUtcTime (&noonTimet, &utcNoonTm); // Generate 'struct tm' for UTC - - // This is not nice, but Visual Studio does not support "strftime(%z)" (get UTC bias) like linux does. - // I'll figure out the UTC bias by comparing readings of local time to UTC for the same moment. - - // Although localTm and utcTm may be different, some secret magic ensures that mktime() will bring - // them back to the same time_t value (as it should: they identify the same moment, just in different timezones). - // I'll just have to work out the utcBias using the differing 'struct tm' values. It isn't pretty. - - utcBiasHours = (localNoonTm.tm_hour - utcNoonTm.tm_hour) - + (localNoonTm.tm_min - utcNoonTm.tm_min) / 60.0; - - // The day may be different between the two times, especially if the local timezone is near the dateline. - // Rollover of tm_yday (from 365 to 0) is a further problem, but no bias is ever more than 24 hours - that wouldn't make sense. - - if (localNoonTm.tm_year > utcNoonTm.tm_year) utcBiasHours += 24.0; // Local time is in a new year, utc isn't: so local time is a day ahead - else if (localNoonTm.tm_year < utcNoonTm.tm_year) utcBiasHours -= 24.0; // Local time is in old year, utc is new year: so local time is a day behind - else utcBiasHours += (localNoonTm.tm_yday - utcNoonTm.tm_yday)*24.0; // Year has not changed, so we can use tm_yday normaly - #endif - /* Windows code: End */ - - /* Linux code: Start */ - #if defined __linux__ || defined __APPLE__ - char buffer [80]; - signed long int tmpLong = 0; - - mktime (&utcTm); // Let "mktime()" do it's magic - - strftime (buffer, 80, "%z", &utcTm); - - if (strlen (buffer) > 0 && myIsNumber (buffer)) - { tmpLong = atol (buffer); - utcBiasHours = (int)(tmpLong/100 + (tmpLong%100)/60.0); - } - #endif - /* Linux code: End */ - - return utcBiasHours; - } - - /* - ** Debug: What's the time (include timezone)? - */ - void myDebugTime (const char * pTitleChar, const time_t *pTimet) - { if (pRun->debug == ONOFF_ON) - { struct tm tmpLocalTm, tmpUtcTm; - char utcBuffer [80]; - char localBuffer [80]; - - // Convert current time to struct tm for UTC and local timezone - myLocalTime (pTimet, &tmpLocalTm); - myUtcTime (pTimet, &tmpUtcTm); - - strftime ( utcBuffer, 80, "%c %Z", &tmpUtcTm); - printf ("Debug: %s utcTm: %s\n", pTitleChar, utcBuffer); - strftime (localBuffer, 80, "%c %Z", &tmpLocalTm); - printf ("Debug: %s localTm: %s\n", pTitleChar, localBuffer); - - // Difference between UTC and local TZ - strftime ( utcBuffer, 80, "%Z", &tmpUtcTm); - strftime (localBuffer, 80, "%Z", &tmpLocalTm); - printf ("Debug: %s UTC bias (add to %s to get %s) hours: %f\n", pTitleChar, utcBuffer, localBuffer, getUtcBiasHours (pTimet)); - } - } - - /* - ** Return time_t of midnight UTC on the day given - ** In effect, this function is going to shave upto 24 hours off a time - ** returning 00:00 UTC on the day given. - */ - time_t getMidnightUTC (const time_t *pTimet, const runStruct *pRun) - { struct tm tmpTm; - - // Convert target "struct tm" to time_t. It'll be set to midnight local time, on the target day. - myUtcTime (pTimet, &tmpTm); - - // Set to the start of the day - tmpTm.tm_hour = 0; - tmpTm.tm_min = 0; - tmpTm.tm_sec = 0; - - // Fiddle with other "struct tm" fields to get things right - tmpTm.tm_wday = 0; // mktime will ignore this when calculating time_t as it contradicts days and months - tmpTm.tm_yday = 0; // mktime will ignore this when calculating time_t as it contradicts days and months - tmpTm.tm_isdst = -1; // -1 means: mktime() must work it out. 0=DST not in effect. 1=DST in effect. (Daylight Savings) - - // Shave off (add) UTC offset, so that time_t is converted from midnight local-time to midnight UTC on the target day - tmpTm.tm_sec += myRound (pRun->utcBiasHours * 3600.0); - - // Let mktime() do it's magic - return mktime (&tmpTm); - } - - /* - ** A utility that helps determine if the given targetStruct is DAY or NIGHT - ** This isn't the end of the matter, as DAY from yesterday or tomorrow - ** could slip past midnight into the target day. Near the dateline - ** a UTC day features midday NIGHT. The sun is high near midnight UTC. - ** - ** THE TARGET DATE MUST BE THE CURRENT DATE (on 1st call, as this function iterates) - */ - OnOff isDay (const runStruct *pRun) - { // If the time is before sunrise or after sunset, I need to know that - // we're not in the daylight of either the neighbouring days. - - targetStruct yesterday; - yesterday.twilightAngle = pRun->twilightAngle; - yesterday.daysSince2000 = pRun->now2000 - 1; - - targetStruct today; - today.twilightAngle = pRun->twilightAngle; - today.daysSince2000 = pRun->now2000; - - targetStruct tomorrow; - tomorrow.twilightAngle = pRun->twilightAngle; - tomorrow.daysSince2000 = pRun->now2000 + 1; - - sunriset (pRun, &yesterday); - sunriset (pRun, &today); - sunriset (pRun, &tomorrow); - - yesterday.southHourUTC -= 24.0; - tomorrow.southHourUTC += 24.0; - - // Get current time (hours from UTC midnight of current day). - // Difftime() returns "seconds", we want "hours". - time_t midnightUTC = getMidnightUTC (&pRun->nowTimet, pRun); - double nowHourUTC = difftime (pRun->nowTimet, midnightUTC) / (3600.0); - - // Get the time (0-24) of sunrise and set, of the three days - double riseHourUTCYesterday = getOffsetRiseHourUTC (pRun, &yesterday); - double setHourUTCYesterday = getOffsetSetHourUTC (pRun, &yesterday); - double riseHourUTCToday = getOffsetRiseHourUTC (pRun, &today); - double setHourUTCToday = getOffsetSetHourUTC (pRun, &today); - double riseHourUTCTomorrow = getOffsetRiseHourUTC (pRun, &tomorrow); - double setHourUTCTomorrow = getOffsetSetHourUTC (pRun, &tomorrow); - - // Figure out if we're between sunrise and sunset (with offset) of any of the three days - return - ( (nowHourUTC >= riseHourUTCYesterday && nowHourUTC <= setHourUTCYesterday) - || (nowHourUTC >= riseHourUTCToday && nowHourUTC <= setHourUTCToday ) - || (nowHourUTC >= riseHourUTCTomorrow && nowHourUTC <= setHourUTCTomorrow ) - ) ? ONOFF_ON : ONOFF_OFF; - } - - /* - ** - ** >>>>> main() <<<<< - ** - */ - - int main (int argc, char *argv[]) - { - pRun = &gRun; - - // Set Default values - pRun->latitude = DEFAULT_LATITUDE; - pRun->longitude = DEFAULT_LONGITUDE; - pRun->offsetHour = 0.0; - pRun->utcBiasHours = 0.0; - pRun->functionVersion = ONOFF_OFF; - pRun->functionUsage = ONOFF_OFF; - pRun->functionWait = ONOFF_OFF; - pRun->functionPoll = ONOFF_OFF; - pRun->functionReport = ONOFF_OFF; - pRun->functionList = ONOFF_OFF; - pRun->debug = ONOFF_OFF; - pRun->reportSunrise = ONOFF_OFF; - pRun->reportSunset = ONOFF_OFF; - pRun->utc = ONOFF_OFF; - - pRun->twilightAngle = TWILIGHT_ANGLE_DAYLIGHT; - - // For target year - int yearInt = NOT_SET; - int monInt = NOT_SET; - int mdayInt = NOT_SET; - - // Return code - int exitCode = EXIT_OK; - - // - // DO NOT PUT CODE BEFORE "debug" ARGUMENT IS KNOWN (UNTIL AFTER COMMAND LINE PARSED) - // - - /* - ** - ** Parse command line arguments - ** - */ - - // Change to all lowercase, just to make life easier ... - myToLower (argc, argv); - - // Look for debug being activated ... - for (int i=1; i < argc; i++) if (!strcmp (argv [i], "debug")) pRun->debug = ONOFF_ON; - - // For each argument - for (int i=1; i < argc; i++) - { - char *arg = argv[i]; - - // Echo argument, if in debug - if (pRun->debug == ONOFF_ON) printf ("Debug: argv[%d]: >%s<\n", i, arg); - - // Strip any hyphen from arguments, but not negative signs of numbers - if (arg[0] == '-' && arg[1] != '\0' && !isdigit(arg[1])) memmove(arg, arg + 1, sizeof arg - 1); - - // Normal help or version info - if (!strcmp (arg, "v") || - !strcmp (arg, "-V") || - !strcmp (arg, "-v") || - !strcmp (arg, "--version") || - !strcmp (arg, "version")) pRun->functionVersion = ONOFF_ON; - else if (!strcmp (arg, "nv") || - !strcmp (arg, "noversion")) pRun->functionVersion = ONOFF_OFF; - - else if (!strcmp (arg, "?") || - !strcmp (arg, "usage") || - !strcmp (arg, "--help") || - !strcmp (arg, "h") || - !strcmp (arg, "-help") || - !strcmp (arg, "help")) pRun->functionUsage = ONOFF_ON; - else if (!strcmp (arg, "nh" ) || - !strcmp (arg, "nousage") || - !strcmp (arg, "nohelp")) pRun->functionUsage = ONOFF_OFF; - - // Major Options - else if (!strcmp (arg, "wait")) pRun->functionWait = ONOFF_ON; - else if (!strcmp (arg, "poll")) pRun->functionPoll = ONOFF_ON; - else if (!strcmp (arg, "report")) pRun->functionReport = ONOFF_ON; - else if (!strcmp (arg, "list")) { // List should have a parameter attached - pRun->functionList = ONOFF_ON; - if (i+1<argc && myIsSignedNumber (argv[i+1])) - pRun->listDays = atoi (argv [++i]); // Note: ++i - else - pRun->listDays = DEFAULT_LIST; - } - - // Minor Options - - // Print output in GMT or local-time - else if (!strcmp (arg, "gmt") || - !strcmp (arg, "utc")) pRun->utc = ONOFF_ON; - else if (!strcmp (arg, "nogmt") || - !strcmp (arg, "noutc")) pRun->utc = ONOFF_OFF; - - // Debug mode - else if (!strcmp (arg, "debug") || - !strcmp (arg, "--debug") || - !strcmp (arg, "--verbose") || - !strcmp (arg, "-v")) pRun->debug = ONOFF_ON; - else if (!strcmp (arg, "nodebug")) pRun->debug = ONOFF_OFF; - - // Poll. Is it DAY or NIGHT? - else if (!strcmp (arg, "e") || - !strcmp (arg, "er") || - !strcmp (arg, "exit") || - !strcmp (arg, "poll") || - !strcmp (arg, "exitreport")) pRun->functionPoll = ONOFF_ON; - else if (!strcmp (arg, "ne") || - !strcmp (arg, "ner") || - !strcmp (arg, "noexit") || - !strcmp (arg, "nopoll") || - !strcmp (arg, "noexitreport")) pRun->functionPoll = ONOFF_OFF; - - // Specify twilight angle - else if (!strcmp (arg, "sun") || - !strcmp (arg, "day") || - !strcmp (arg, "light") || - !strcmp (arg, "normal") || - !strcmp (arg, "visible") || - !strcmp (arg, "daylight")) pRun->twilightAngle = TWILIGHT_ANGLE_DAYLIGHT; - else if (!strcmp (arg, "civil") || - !strcmp (arg, "civ")) pRun->twilightAngle = TWILIGHT_ANGLE_CIVIL; - else if (!strcmp (arg, "nautical") || - !strcmp (arg, "nau") || - !strcmp (arg, "naut")) pRun->twilightAngle = TWILIGHT_ANGLE_NAUTICAL; - else if (!strcmp (arg, "astronomical") || - !strcmp (arg, "ast") || - !strcmp (arg, "astr") || - !strcmp (arg, "astro")) pRun->twilightAngle = TWILIGHT_ANGLE_ASTRONOMICAL; - else if (!strcmp (arg, "a") || - !strcmp (arg, "angle") || - !strcmp (arg, "twilightangle") || - !strcmp (arg, "twilight")) { if (i+1<argc && myIsSignedFloat (argv[i+1])) - pRun->twilightAngle = atof (argv [++i]); // Note: "++i" - else - pRun->twilightAngle = TWILIGHT_ANGLE_DAYLIGHT; - } - - // Specify target date (default is today) - else if (!strcmp (arg, "y") && i+1<argc && myIsNumber (argv[i+1])) yearInt = atoi (argv [++i]); // Note: "++i" - else if (!strcmp (arg, "m") && i+1<argc && myIsNumber (argv[i+1])) monInt = atoi (argv [++i]); // Note: "++i" - else if (!strcmp (arg, "d") && i+1<argc && myIsNumber (argv[i+1])) mdayInt = atoi (argv [++i]); // Note: "++i" - - // Specify fixed duration offset - else if (!strcmp (arg, "o") || - !strcmp (arg, "off") || - !strcmp (arg, "offset")) { if (i+1<argc && isOffset (pRun, argv[i+1])) { ++i; } /* Functionality in "isOffset()" */ - } - - // Specify if sunrise and/or sunset timings a required. - else if (!strcmp (arg, "sunrise") || - !strcmp (arg, "rise") || - !strcmp (arg, "dawn") || - !strcmp (arg, "sunup") || - !strcmp (arg, "up")) pRun->reportSunrise = ONOFF_ON; - else if (!strcmp (arg, "sunset") || - !strcmp (arg, "set") || - !strcmp (arg, "dusk") || - !strcmp (arg, "sundown") || - !strcmp (arg, "down")) pRun->reportSunset = ONOFF_ON; - - // Specify latitude and longitude - quite complex, so I've handled it elsewhere - else if (isBearing (pRun, arg)) {} /* Functionality in "isBearing()" */ - - // Don't know what in on the command line, so complain. - else printf ("Error: Unknown command-line argument: %s\n", arg); - } - - - /* - ** - ** Analyse command line, check for errors and fill in gaps - ** - */ - - if (pRun->debug == ONOFF_ON) - { if (pRun->utc == ONOFF_ON) - printf ("Debug: All output to use UTC.\n"); - else - printf ("Debug: All output to use local timezone (nogmt).\n"); - } - - - /* - ** Get: current time (time_t is UTC, always) and bias of local-time from UTC - */ - - time (&pRun->nowTimet); - if (pRun->debug == ONOFF_ON) myDebugTime ("Now", &pRun->nowTimet); - - pRun->utcBiasHours = getUtcBiasHours (&pRun->nowTimet); - if (pRun->debug == ONOFF_ON) printf ("Debug: UTC Bias (hours): %f\n", pRun->utcBiasHours); - - pRun->now2000 = daysSince2000 (&pRun->nowTimet); - if (pRun->debug == ONOFF_ON) printf ("Debug: Now: Days since 2000: %lu\n", pRun->now2000); - - - /* - ** Get: Target Date - */ - - { struct tm targetTm; - - // Populate targetTm :- - // Get the target day (as "struct tm") for "now" - the default - // I'll get the local-time day, as it'll make sense with the user, unless UTC was asked for - // - - if (pRun->utc == ONOFF_ON) - myUtcTime (&pRun->nowTimet, &targetTm); // User wants UTC - else - myLocalTime (&pRun->nowTimet, &targetTm); // User gets local timezone - - // - // Parse "target" year, month and day [adjust target] - // - - if (yearInt != NOT_SET) - { if (yearInt < 0 || yearInt > 99) - { printf ("Error: \"Year\" must be between 0 and 99: %u\n", yearInt); - exit (EXIT_ERROR); - } - targetTm.tm_year = yearInt + 100; - } - if (pRun->debug == ONOFF_ON) printf ("Debug: Target year set to: %u\n", targetTm.tm_year); - - if (monInt != NOT_SET) - { if (monInt < 1 || monInt > 12) - { printf ("Error: \"Month\" must be between 1 and 12: %u\n", monInt); - exit (EXIT_ERROR); - } - targetTm.tm_mon = monInt-1; // We need month 0 to 11, not 1 to 12 - } - if (pRun->debug == ONOFF_ON) printf ("Debug: Target mon set to: %u\n", targetTm.tm_mon); - - if (mdayInt != NOT_SET) - { if (mdayInt < 1 || mdayInt > 31) - { printf ("Error: \"Day of month\" must be between 1 and 31: %u\n", mdayInt); - exit (EXIT_ERROR); - } - targetTm.tm_mday = mdayInt; - } - if (pRun->debug == ONOFF_ON) printf ("Debug: Target mday set to: %u\n", targetTm.tm_mday); - - // Set target time to the start of the UTC day - targetTm.tm_hour = 0; - targetTm.tm_min = 0; - targetTm.tm_sec = 0; - - // Fiddle with other "struct tm" fields to get things right - targetTm.tm_wday = 0; // mktime will ignore this when calculating time_t as it contradicts days and months - targetTm.tm_yday = 0; // mktime will ignore this when calculating time_t as it contradicts days and months - targetTm.tm_isdst = -1; // -1 means: mktime() must work it out. 0=DST not in effect. 1=DST in effect. (Daylight Savings) - - // Convert target "struct tm" to time_t. It'll be set to midnight local time, on the target day. - pRun->targetTimet = mktime (&targetTm); - - // Shave off (add) UTC offset, so that time_t is converted from midnight local-time to midnight UTC on the target day - targetTm.tm_sec += myRound (pRun->utcBiasHours * 60.0 * 60.0); - - // Adjustment below suggested by Phos Quartz on sourceforge.net to - // address the case when invocation time and target time are not - // in the same timezone (i.e. standard time vs daylight time) - // see https://sourceforge.net/p/sunwait4windows/discussion/general/thread/98fc17dd5f/ - struct tm localTm; - myLocalTime (&pRun->nowTimet, &localTm); - int isdst = localTm.tm_isdst; - targetTm.tm_isdst = isdst; - - // All done - pRun->targetTimet = mktime (&targetTm); // <<<<<< The important bit done <<< targetTimet is set to midnight UTC - - if (pRun->debug == ONOFF_ON) myDebugTime ("Target", &pRun->targetTimet); - } - - pRun->target2000 = daysSince2000 (&pRun->targetTimet); - if (pRun->debug == ONOFF_ON) printf ("Debug: Target: Days since 2000: %lu\n", pRun->target2000); - - /* - ** Check: Latitude and Longitude - */ - - if (pRun->latitude == NOT_SET) - { if (pRun->debug == ONOFF_ON) printf ("Debug: latitude not set. Default applied.\n"); - pRun->latitude = DEFAULT_LATITUDE; - } - - if (pRun->longitude == NOT_SET) - { if (pRun->debug == ONOFF_ON) printf ("Debug: longitude not set. Default applied.\n"); - pRun->longitude = DEFAULT_LONGITUDE; - } - - // /* Co-ordinates must be in 0 to 360 range */ // IFC 2014-12-02: Removed as done in isBearing() - // pRun->latitude = revolution (pRun->latitude); // IFC 2014-12-02: Removed as done in isBearing() - // pRun->longitude = revolution (pRun->longitude); // IFC 2014-12-02: Removed as done in isBearing() - - if (pRun->debug == ONOFF_ON) - { printf ("Debug: Co-ordinates - Latitude: %fN\n", pRun->latitude); - printf ("Debug: Co-ordinates - Longitude: %fE\n", pRun->longitude); - } - - /* - ** Check: Twilight Angle - */ - - if (pRun->twilightAngle == NOT_SET) - { if (pRun->debug == ONOFF_ON) printf ("Debug: twilight angle not set. Default: daylight.\n"); - pRun->twilightAngle = TWILIGHT_ANGLE_DAYLIGHT; - } - - if (pRun->twilightAngle <= -90 || pRun->twilightAngle >= 90) - { - printf ("Error: Twilight angle must be between -90 and +90 (-ve = below horizon), your setting: %f\n", pRun->twilightAngle); - pRun->twilightAngle = TWILIGHT_ANGLE_DAYLIGHT; - } - - if (pRun->debug == ONOFF_ON) - { if (pRun->twilightAngle == TWILIGHT_ANGLE_DAYLIGHT) printf ("Debug: Twilight - Daylight\n"); - else if (pRun->twilightAngle == TWILIGHT_ANGLE_CIVIL) printf ("Debug: Twilight - Civil\n"); - else if (pRun->twilightAngle == TWILIGHT_ANGLE_NAUTICAL) printf ("Debug: Twilight - Nautical\n"); - else if (pRun->twilightAngle == TWILIGHT_ANGLE_ASTRONOMICAL) printf ("Debug: Twilight - Astronomical\n"); - else printf ("Debug: Twilight - Custom angle (degrees): %f\n", pRun->twilightAngle); - } - - /* - ** Check: Offset - */ - - if (pRun->debug == ONOFF_ON) printf ("Debug: User specified offset (hours): %f\n", pRun->offsetHour); - - - /* - ** Check: Major-option or Function - */ - - // IF no function requested THEN default to "usage" - if - ( pRun->functionList == ONOFF_OFF - && pRun->functionPoll == ONOFF_OFF - && pRun->functionUsage == ONOFF_OFF - && pRun->functionVersion == ONOFF_OFF - && pRun->functionWait == ONOFF_OFF - && pRun->functionReport == ONOFF_OFF - ) pRun->functionUsage = ONOFF_ON; - - /* - ** Check: Sunrise or sunset. IF neither set THEN set both - */ - - if (pRun->reportSunrise == ONOFF_OFF && pRun->reportSunset == ONOFF_OFF) - { pRun->reportSunrise = ONOFF_ON; - pRun->reportSunset = ONOFF_ON; - } - - /* - ** OK - we're all done figuring out what to do - let's do it - */ - - if (pRun->functionVersion == ONOFF_ON) - { if (pRun->debug == ONOFF_ON) printf ("Debug: Function selected: Version\n"); - print_version (); - exitCode = EXIT_OK; - } - - if (pRun->functionUsage == ONOFF_ON) - { if (pRun->debug == ONOFF_ON) printf ("Debug: Function selected: Usage\n"); - print_usage (); - exitCode = EXIT_OK; - } - - if (pRun->functionReport == ONOFF_ON) - { if (pRun->debug == ONOFF_ON) printf ("Debug: Function selected: Report\n"); - generate_report (pRun); - exitCode = EXIT_OK; - } - - if (pRun->functionList == ONOFF_ON) - { if (pRun->debug == ONOFF_ON) printf ("Debug: Function selected: List\n"); - print_list (pRun); - exitCode = EXIT_OK; - } - - if (pRun->functionWait == ONOFF_ON) - { if (pRun->debug == ONOFF_ON) printf ("Debug: Function selected: Wait\n"); - exitCode = wait (pRun); - } - - if (pRun->functionPoll == ONOFF_ON) - { if (pRun->debug == ONOFF_ON) printf ("Debug: Function selected: Poll\n"); - exitCode = poll (pRun); - if (exitCode == EXIT_DAY) printf ("DAY\n"); - else if (exitCode == EXIT_NIGHT) printf ("NIGHT\n"); - else if (exitCode == EXIT_OK) printf ("OK\n"); - else if (exitCode == EXIT_ERROR) printf ("ERROR\n"); - } - - exit (exitCode); - } - - /* - ** Simply check if we think now/current-time is night OR day (day includes twilight) - */ - inline int poll (const runStruct *pRun) - { return isDay (pRun) == ONOFF_ON ? EXIT_DAY : EXIT_NIGHT; - } - - /* - ** Wait until sunrise or sunset occurs on the target day. - ** That sounds simple, until you start to consider longitudes near the dateline. - ** Midnight UTC can lands later and later within a local day for large longitudes. - ** Latitudes heading towards the poles can either shrink the day length to nothing or the whole day, depending on the season. - ** A user-specified offset messes around with daylength too. - ** Exit immediately if its a polar day or midnight sun (including offset). - */ - int wait (const runStruct *pRun) - { - /* - ** Calculate start/end of twilight for given twilight type/angle. - ** For latitudes near poles, the sun might not pass through specified twilight angle that day. - ** For big longitudes, it's quite likely the sun is up at midnight UTC: this means we have to calculate successive days. - */ - - targetStruct yesterday; - yesterday.twilightAngle = pRun->twilightAngle; - yesterday.daysSince2000 = pRun->target2000 - 1; - - targetStruct today; - today.twilightAngle = pRun->twilightAngle; - today.daysSince2000 = pRun->target2000; - - targetStruct tomorrow; - tomorrow.twilightAngle = pRun->twilightAngle; - tomorrow.daysSince2000 = pRun->target2000 + 1; - - sunriset (pRun, &yesterday); - sunriset (pRun, &today); - sunriset (pRun, &tomorrow); - - yesterday.southHourUTC -= 24; - tomorrow.southHourUTC += 24; - - // Calculate duration (seconds) from "now" to "midnight UTC on the target day". [difftime (end, beginning)] - long waitMidnightUTC = static_cast <long> (difftime (pRun->targetTimet, pRun->nowTimet)); - - // Calculate duration to wait for each day's rise and set (seconds) - // (targetTimet is set to midnight on the target day) - long waitRiseYesterday = waitMidnightUTC + static_cast <long> ( 3600.0 * getOffsetRiseHourUTC (pRun, &yesterday) ); - long waitSetYesterday = waitMidnightUTC + static_cast <long> ( 3600.0 * getOffsetSetHourUTC (pRun, &yesterday) ); - long waitRiseToday = waitMidnightUTC + static_cast <long> ( 3600.0 * getOffsetRiseHourUTC (pRun, &today) ); - long waitSetToday = waitMidnightUTC + static_cast <long> ( 3600.0 * getOffsetSetHourUTC (pRun, &today) ); - long waitRiseTomorrow = waitMidnightUTC + static_cast <long> ( 3600.0 * getOffsetRiseHourUTC (pRun, &tomorrow) ); - long waitSetTomorrow = waitMidnightUTC + static_cast <long> ( 3600.0 * getOffsetSetHourUTC (pRun, &tomorrow) ); - - // Determine next sunrise and sunset - // (we may be in DAY, so the next event is sunset - followed by sunrise) - - long waitRiseSeconds = 0; - long waitSetSeconds = 0; - - if (waitRiseYesterday > 0) { waitRiseSeconds = waitRiseYesterday; waitSetSeconds = waitSetYesterday; } - else if (waitSetYesterday > 0) { waitRiseSeconds = waitRiseToday; waitSetSeconds = waitSetYesterday; } - else if (waitRiseToday > 0) { waitRiseSeconds = waitRiseToday; waitSetSeconds = waitSetToday; } - else if (waitSetToday > 0) { waitRiseSeconds = waitRiseTomorrow; waitSetSeconds = waitSetToday; } - else if (waitRiseTomorrow > 0) { waitRiseSeconds = waitRiseTomorrow; waitSetSeconds = waitSetTomorrow; } - else if (waitSetTomorrow > 0) { waitRiseSeconds = 0; waitSetSeconds = waitSetTomorrow; } - - // Is it currently DAY or NIGHT? - - OnOff isDay = ONOFF_OFF; - - if (waitRiseYesterday > 0) { isDay = ONOFF_OFF; } - else if (waitSetYesterday > 0) { isDay = ONOFF_ON; } - else if (waitRiseToday > 0) { isDay = ONOFF_OFF; } - else if (waitSetToday > 0) { isDay = ONOFF_ON; } - else if (waitRiseTomorrow > 0) { isDay = ONOFF_OFF; } - else if (waitSetTomorrow > 0) { isDay = ONOFF_ON; } - - // Determine if the day is "normal" (where the rises and sets) or "polar" ("midnight sun" or "polar night") - - bool exitPolar = false; - - if (waitSetYesterday > 0) { double diurnalArc = diurnalArcWithOffset (pRun, &yesterday); exitPolar = diurnalArc <= 0.0 || diurnalArc >= 24.0; } - else if (waitSetToday > 0) { double diurnalArc = diurnalArcWithOffset (pRun, &today); exitPolar = diurnalArc <= 0.0 || diurnalArc >= 24.0; } - else { double diurnalArc = diurnalArcWithOffset (pRun, &tomorrow); exitPolar = diurnalArc <= 0.0 || diurnalArc >= 24.0; } - - if (exitPolar) - { if (pRun->debug == ONOFF_ON) printf ("Debug: Polar region or large offset: No sunrise today, there's nothing to wait for!\n"); - return EXIT_ERROR; - } - - // Get next rise or set time UNLESS the opposite event happens first (unless less than 6 hours to required event) - // IF both rise and set requested THEN wait for whichever is next - - long waitSeconds = 0; - - if (pRun->reportSunrise == ONOFF_ON && pRun->reportSunset == ONOFF_OFF) - { if (isDay == ONOFF_OFF || waitRiseSeconds < 6*60*60) waitSeconds = waitRiseSeconds; } - else if (pRun->reportSunrise == ONOFF_OFF && pRun->reportSunset == ONOFF_ON) - { if (isDay == ONOFF_ON || waitSetSeconds < 6*60*60) waitSeconds = waitSetSeconds; } - else - { waitSeconds = waitRiseSeconds < waitSetSeconds ? waitRiseSeconds : waitSetSeconds; } - - // Don't wait if event has passed (or next going to occur soon [6hrs]) - if (waitSeconds <= 0) - { if (pRun->debug == ONOFF_ON) printf ("Debug: Event already passed today, can't wait for that!\n"); - return EXIT_ERROR; - } - - // - // In debug mode, we don't want to wait for sunrise or sunset. Wait a minute instead. - // - - if (pRun->debug == ONOFF_ON) - { printf("Debug: Wait reduced from %li to 10 seconds.\n", waitSeconds); - waitSeconds = 10; - } - else if (pRun->functionPoll == ONOFF_ON) waitSeconds += 60; // Make more sure that a subsequent POLL works properly (wink ;-) - - /* - ** Sleep (wait) until the event is expected - */ - - /* Windows code: Start */ - #if defined _WIN32 || defined _WIN64 - waitSeconds *= 1000; // Convert hours to milliseconds for Windows - Sleep ((DWORD) waitSeconds); // Windows-only . waitSec is tested positive or zero - #endif - /* Windows code: End */ - - /* Linux code: Start */ - #if defined __linux__ || defined __APPLE__ - sleep (waitSeconds); // Linux-only (seconds OK) - #endif - /* Linux code: End */ - - return EXIT_OK; - }
• sunwait.h
  • @@ -16,7 +16,6 @@ #define DEFAULT_ANGLE 0.83 /* Default twighlight angle. */
    #define DEFAULT_LATITUDE 40.108306 #define DEFAULT_LONGITUDE -89.7427 /* South Side School, Champaign, IL, USA */ - #define boolean bool #define NOT_SET 9999999 #define SET 1111111
  • @@ -26,7 +25,7 @@ , ONOFF_OFF
    } OnOff; typedef struct - { + { double latitude; // Degrees N - Global position double longitude; // Degrees E - Global position
  • @@ -59,7 +58,7 @@
    } runStruct; typedef struct - { + { // "Input" data double twilightAngle; // Degrees. -ve = below horizon. Can be: daylight, civil, nautical, astronomical, or custom. unsigned long daysSince2000; // The sunrise calculation needs this: days from start of 2000 to targetTimet
  • @@ -84,8 +83,8 @@ void myLocalTime (const time_t * ptrTimet, struct tm * ptrTm);
    OnOff isDay (const runStruct *pRun); - int poll (const runStruct *pRun); - int wait (const runStruct *pRun); + int sunpoll (const runStruct *pRun); + int sunwait (const runStruct *pRun); #endif