Python递归错误：超过最大递归深度

我有一个python程序，我写的，移动我的太阳能电池板与太阳整天。它工作得很好，但大约每周我会收到两次递归错误：超过了最大递归深度

我对python非常陌生，我查过递归错误，它说当一个函数调用自己太多次时，我看不出在这个程序中发生了什么

    from datetime import date
    from datetime import datetime, timezone, timedelta
    import astral
    from astral import Astral
    import time
    import pytz


    # import RPi.GPIO as GPIO

    # Global Variables
    ast = Astral()
    city_Name = 'Cleveland'
    local_City = ast[city_Name]
    # sun_Position = local_City.sun(local=True)
    reset_Solar = True

    # Retrieves and returns current time
    def get_Current_Time():
        eastern = pytz.timezone('America/New_York')
        curr_Time = datetime.now(eastern)
        return curr_Time

    def main_Function():
        global local_City
        sun_Position = local_City.sun(local=True)
        current_Time = get_Current_Time()
        solar_Sunrise = sun_Position.get('sunrise')
        solar_Noon = sun_Position.get('noon')
        solar_Sunset = sun_Position.get('sunset')
        calc_Sunrise_Noon = solar_Noon - solar_Sunrise

        total_Seconds = calc_Sunrise_Noon.seconds
        calc_Hours, remainder = divmod(total_Seconds, 3600)
        calc_Minutes, calc_Seconds = divmod(remainder, 60)

        time_To_Adjust = total_Seconds / 24

        print (current_Time)
        print (solar_Sunrise)

        if current_Time >= solar_Sunrise and current_Time < solar_Sunset:
            solar_Adjust_Active(time_To_Adjust)
        elif reset_Solar == True:
            reset_Solar_Panel()
        else:
            solar_Adjust_Deactive()

    def solar_Adjust_Active(time_To_Adjust):

        while time_To_Adjust > 0:
            current_Time = get_Current_Time()
            time_To_Adjust = time_To_Adjust - 1
            time.sleep(1)
            print (current_Time)
            print (time_To_Adjust)
        daylight_Adjustment()

    def solar_Adjust_Deactive():
        global local_City
        curr_Time = get_Current_Time()
        calc_Tomorrow = curr_Time.date() + timedelta(days=1)
        sun_Position_Tomorrow = local_City.sun(local=True, date = calc_Tomorrow)
        solar_Sunrise_Tomorrow = sun_Position_Tomorrow.get('sunrise')

        time_Till_Sunrise = solar_Sunrise_Tomorrow - curr_Time

        sunrise_Total_Seconds = time_Till_Sunrise.seconds
        calc_Sunrise_Hours, remainder = divmod(sunrise_Total_Seconds, 3600)
        calc_Sunrise_Minutes, calc_Sunrise_Seconds = divmod(remainder, 60)

        while sunrise_Total_Seconds > 0:
            sunrise_Total_Seconds = sunrise_Total_Seconds - 1
            time.sleep(1)
            # print ('Seconds till Sunrise', sunrise_Total_Seconds)
        print (solar_Sunrise_Tomorrow)
        main_Function()

    def daylight_Adjustment():
        global reset_Solar
        # Adustment to Solar Panel
        #GPIO.setmode(GPIO.BCM)

        # init pin numbers
        #pin_Open = [6]

        # set mode default state is 'low'
        #GPIO.setup(pin_Open, GPIO.OUT) 

        # Activate Open Relay to High (High turns Relay on)
        #GPIO.output(pin_Open, GPIO.HIGH)     # Activate Open relay

        # Start Timer for duration actuator will be activated
        timer = 0
        while timer < 1:
            time.sleep(1)
            timer = timer + 1

        print ('Panal adjusted')
        # set Open relay back to low (Turns Relay off)
        #GPIO.output(pin_Open, GPIO.LOW)

        # Reset GPIO settings
        #GPIO.cleanup()

        reset_Solar = True
        main_Function()

     def reset_Solar_Panel():
        global reset_Solar
        print ('Setting panel back to original position')
        # Adustment to Solar Panel
        # GPIO.setmode(GPIO.BCM)

        # init pin numbers
        # pin_Open = [XX]

        # set mode default state is 'low'
        # GPIO.setup(pin_Open, GPIO.OUT) 

        # Activate Open Relay to High (High turns Relay on)
        # GPIO.output(pin_Open, GPIO.HIGH)     # Activate Open relay

        # Start Timer for duration actuator will be activated
        timer = 0
        while timer <= 48:
            time.sleep(1)
            timer = timer + 1

        # set Open relay back to low (Turns Relay off)
        # GPIO.output(pin_Open, GPIO.LOW)

        # Reset GPIO settings
        # GPIO.cleanup()

        reset_Solar = False
        main_Function()

    main_Function()

from datetime导入日期
从datetime导入datetime、时区、timedelta
进口星体
从星体导入星体
导入时间
进口皮茨
#将RPi.GPIO导入为GPIO
#全局变量
ast=星体（）
城市名称=‘克利夫兰’
本地城市=ast[城市名称]
#sun\u位置=本地城市。sun（本地=真）
重置太阳能=真
#检索并返回当前时间
def get_Current_Time（）：
东部=pytz.时区（“美国/纽约”）
curr_Time=datetime.now（东部）
返回当前时间
def main_函数（）：
全球地方城市
sun\u位置=本地城市。sun（本地=真）
当前时间=获取当前时间（）
太阳日出=太阳位置。获取（'Sunrise'）
太阳中午=太阳位置。获取（'Noon'）
太阳日落=太阳位置。获取（“日落”）
计算日出中午=太阳中午-太阳日出
总秒数=计算日出秒数
计算小时数，余数=divmod（总秒数，3600）
计算分钟，计算秒=divmod（余数，60）
调整时间=总秒/24
打印（当前时间）
印刷品（太阳日出）
如果当前时间>=太阳日出，当前时间<太阳日落：
太阳能调节激活（时间调节）
elif reset_Solar==真：
重置太阳能电池板（）
其他：
太阳能调节器
def solar_Adjust_Active（调整时间）：
调整时间>0时：
当前时间=获取当前时间（）
调整时间=调整时间-1
时间。睡眠（1）
打印（当前时间）
打印（调整时间）
日光调节（）
def solar_Adjust_Deactive（）：
全球地方城市
当前时间=获取当前时间（）
明天计算=当前时间.日期（）+时间增量（天=1）
太阳位置明天=本地城市。太阳（本地=真，日期=明天计算）
明天太阳日出=明天太阳位置。获取（'Sunrise'））
直到日出的时间=太阳明天日出-当前时间
日出总秒=日出前的时间秒
计算日出小时数，余数=divmod（日出总秒数，3600）
计算日出分钟数，计算日出秒数=divmod（余数，60）
当日出总秒数>0时：
日出总秒数=日出总秒数-1
时间。睡眠（1）
#打印（“日出前的秒数”，日出总秒数）
印刷品（明天太阳日出）
主函数（）
def日光调节（）
全球太阳能
#太阳能电池板的安装
#GPIO.setmode（GPIO.BCM）
#初始pin码
#引脚_打开=[6]
#设置模式默认状态为“低”
#GPIO.setup（引脚打开，GPIO.OUT）
#激活开路继电器至高电平（高电平使继电器接通）
#GPIO.输出（引脚_开路，GPIO.高）#激活开路继电器
#持续时间执行器的启动计时器将被激活
计时器=0
当定时器<1时：
时间。睡眠（1）
定时器=定时器+1
打印（'Panal adjusted'）
#将开路继电器设置回低位（关闭继电器）
#GPIO.output（引脚_打开，GPIO.LOW）
#重置GPIO设置
#GPIO.cleanup（）
重置太阳能=真
主函数（）
def复位太阳能电池板（）：
全球太阳能
打印（'将面板设置回原始位置'）
#太阳能电池板的安装
#GPIO.setmode（GPIO.BCM）
#初始pin码
#引脚_打开=[XX]
#设置模式默认状态为“低”
#GPIO.setup（引脚打开，GPIO.OUT）
#激活开路继电器至高电平（高电平使继电器接通）
#GPIO.输出（引脚_开路，GPIO.高）#激活开路继电器
#持续时间执行器的启动计时器将被激活
计时器=0
当定时器时，代码中有（至少一个）循环：

def main_Function(): 
->  solar_Adjust_Active(time_To_Adjust)  
->  daylight_Adjustment() 
->  main_Function() -> .... # lets run that for a couple of days ...

通常情况下，您有一个主循环（例如，True:

）并在不递归的情况下从函数调用/返回主循环：

伪代码：

def resetToStart():
    move panels to sunrise position
    return

def movePanel():
    get_currnt_optimal_position_for_datetime
    move_to_that_position
    return

resetToStart()  # start at a well known position
while True:
    if NightTime:  # sun is down
        resetToStart() 
        sleep till daytime
    elif DayTime:  # sun is up
        movePanel() 
        sleep some till adjustment needed

---

嗯，您的

main_函数（）

在某些情况下调用

reset_Solar_Panel（）

，然后调用

main_函数（）。这就解释了递归限制超出了错误。好吧，看看你写的，这很有意义。我已经调整了程序，我会让它运行大约一周，看看是否有任何错误。谢谢你的帮助。