import operator

# first set the desired frequency and constraints
input_f_xtal  =   20_000_000            # 20 MHz crystal on the inputs
input_f_cpu   =  333_333_333            # 297 MHz should go to the CPU
#input_f_error =      250_000           # allow 100 KHz error
input_f_error =  input_f_cpu*1e-6*100   # allow 100 ppm tollerance

def main():
    # determin if the crystal frequency is in bound. values from cgracey assembler file
    if input_f_xtal < 250_000:
        print ("Sorry, {:,} Hz is to low for the crystal frequency".format(input_f_xtal))
        return
    if input_f_xtal > 500_000_000:
        print ("Sorry, {:,} Hz is to high for the crystal frequency".format(input_f_xtal))
        return    
    # determin if we are in reachable bounds for f_cpu. values from cgracey assembler file
    if input_f_cpu < 3_333_333:
        print ("Sorry, can not reach {:,} Hz on f_cpu. It is too low".format(input_f_cpu))
        return
    if input_f_cpu > 500_000_000:
        print ("Sorry, can not reach {:,} Hz on f_cpu. It is too high".format(input_f_cpu))
        return
    
    # now iterate calculate and record results
    CalculatedValues=list()    
    # iterate postDivider
    for phelp in range (0,16): # 0..15
        #calc the real postDivider
        if phelp==15:
            pre=1
        else:
            pre=(phelp+1)*2        
        # iterate PLL mulitiplier    
        for mul in range (1,1025): # 1..1024           
            # iterate preDivider
            for post in range (1,65): # 1..64
                f_afterpre = input_f_xtal / pre
                if f_afterpre<250_000: # do not predivide below 250 KHz. value from forum
                    continue
                f_vco = f_afterpre * mul
                if f_vco<100_000_000 or f_vco >500_000_000: #make sure the VCO runs between 100 and 500 MHz
                    continue
                f_cpu = round(f_vco/post) #round for a whole numer
                if f_cpu<3_333_333 or f_cpu >500_000_000: #make sure the cpu runs between 3.333 and 500 MHz
                    continue                        
                error = abs(f_cpu - input_f_cpu)                
                if error>input_f_error:
                    continue
                    
                CalculatedValues.append(RegisterValues(pre,mul,post,error))
            ##end for post
        ##end for mul
    ##end for pre
            
    # now sort the list by error,pre then post
    CalculatedValues.sort(key=operator.attrgetter("error","pre","post"))


    # now print the things we have found
    index=0
    while index<3 and index<len(CalculatedValues):
        print ("'Option {}:".format (index+1))
        
        pre  = CalculatedValues[index].pre
        mul  = CalculatedValues[index].mul
        post = CalculatedValues[index].post
        
        f_pre = round(input_f_xtal/pre)
        f_vco = round(input_f_xtal/pre*mul)
        f_cpu = round(input_f_xtal/pre*mul/post)
        error = abs(f_cpu - input_f_cpu)
        
        # now calc all the bits
        prebits= pre-1
        mulbits= mul-1
        if post==1:
            postbits=15
        else:
            postbits=round(post/2)
        # now shift them around      
        print ("'set CPU clock to {:,} Hz with error {:,} Hz.".format(input_f_cpu,error))
        print ("'f_xtal={:,} Hz, f_pre={:,} Hz, f_vco={:,} Hz, f_cpu={:,} Hz".format(input_f_xtal,f_pre,f_vco,f_cpu))
        print ("'PreDivide={:,}+1, PLLMultiply={:,}+1, PostDivide={:,} means divide vco by {:,}".format(prebits,mulbits,postbits,post))
        print ("'PreDivide={:#06b}, PLLMultiply={:#010b}, PostDivide={:#04b}".format(prebits,mulbits,postbits))
        print ("\tHUBSET  #%1111_00_00                        'VCO/1, Hi-Z, 20MHz+ internal osc.")
        print ("\tHUBSET  ##%1_{:06b}_{:010b}_{:04b}_10_00   'enable crystal+PLL, but stay in 20MHz+ mode".format(prebits,mulbits,postbits))
        print ("\tWAITX   ##20_000_000                       'wait ~10ms for crystal+PLL to stabilize.")
        print ("\tHUBSET  ##%1_{:06b}_{:010b}_{:04b}_10_11   'now switch to PLL running at {:,} Hz".format(prebits,mulbits,postbits,f_cpu))
        index = index +1
        
    ##end while
    
    if (len (CalculatedValues)==0):
        print ("Nothing Found") 
    ##end main    

##types
# class to make my found values nicely acessable and readable
class RegisterValues:
    def __init__(self, pre, mul, post, error):
        self.pre = pre
        self.mul = mul
        self.post = post
        self.error = error
    def __repr__(self):
        return repr(("pre:{}, mul:{}, post:{}, error:{}".format(self.pre,self.mul,self.post,self.error)))
    ## end class

## Make sure main wil be called as python normaly has no main method    
if __name__ == '__main__':
    main()