hypernova/interface.py at main · dalegaard/hypernova · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
#!/usr/bin/python3

from litex import RemoteClient
import csv
from ast import literal_eval
from os import path

bases = {}
registers = {}
with open(path.join(path.dirname(path.realpath(__file__)), 'build', 'csr.csv')) as f:
    rdr = csv.reader(f)
    for row in rdr:
        if row[0].strip().startswith('#'):
            continue
        [kind, name, *rest] = row
        match kind:
            case "csr_base":
                bases[name] = literal_eval(rest[0])
            case "csr_register":
                registers[name] = (literal_eval(rest[0]), literal_eval(rest[1]))

regs_base = bases['stepgen']

per_stepper_regs = {}

def init():
    global per_stepper_regs
    prefix = "stepgen_outputs_0_"
    stepper_regs = {key[len(prefix):]: value for (key, value) in registers.items() if key.startswith(prefix)}
    base_reg = min([addr for (_key, (addr, _size)) in stepper_regs.items()])
    per_stepper_regs = {
        key: int((addr - base_reg) / 4)
        for (key, (addr, _size))
        in stepper_regs.items()
    }
init()

num_steppers = 4
stepper_regs_offset = 8
stepper_regs_len = (1+max(per_stepper_regs.values()))*4
total_length = stepper_regs_offset + num_steppers * stepper_regs_len

def stepper_reg(stepper, reg):
    return regs_base + stepper_regs_offset + stepper_regs_len * stepper + per_stepper_regs[reg] * 4

def dt_to_clocks(dt):
    return int(dt * 62500000)

class StepgenController:
    def __init__(self):
        self.client = RemoteClient()
        self.client.open()

    def current_time(self):
        return self.client.read(bases['timebase'] + 4)

    def get_error_stage(self, idx):
        return self.client.read(stepper_reg(idx, "error_state"))

    def set_last_step(self, idx, value):
        self.client.write(stepper_reg(idx, "last_step"), value)

    def get_current_step(self, idx):
        return self.client.read(stepper_reg(idx, "current_step"))

    def get_config(self, idx):
        return self.client.read(stepper_reg(idx, "config"))

    def set_config_bit(self, idx, bit, value):
        mask = ~(1 << bit)
        value = value << bit
        self.client.write(stepper_reg(idx, "config"), (self.get_config(idx) & mask) | value)

    def set_config_step_both_edges(self, idx, value):
        self.set_config_bit(idx, 0, value)

    def queue(self, idx, interval, count, add):
        self.client.write(stepper_reg(idx, "next_dir"), 0 if count >= 0 else 1)
        self.client.write(stepper_reg(idx, "next_add"), add)
        self.client.write(stepper_reg(idx, "next_count"), abs(count))
        self.client.write(stepper_reg(idx, "push_interval"), interval)

    def flush(self, idx):
        self.client.write(stepper_reg(idx, "flush"), 1)

if __name__ == "__main__":
    controller = StepgenController()

    stepper = 0

    print(controller.get_error_stage(stepper))

    controller.set_config_step_both_edges(stepper, True)

    # controller.flush(stepper)
    # count = controller.get_current_step(stepper)
    controller.set_last_step(stepper, (controller.current_time() + dt_to_clocks(1)) & 0xFFFFFFFF)
    # if count > 0:
    #     while count > 0:
    #         sub = min(count, 0xFFFF)
    #         controller.queue(stepper, dt_to_clocks(0.0001), -sub, 0)
    #         count -= sub
    # else:
    controller.queue(stepper, dt_to_clocks(0.001), 60000, 0)
    # controller.queue(stepper, 1000, 1, 0)
    # controller.queue(stepper, 10, 60000, 0)
    # controller.queue(stepper, 3000, -1, 0)