def simulate(self): elf = self.cc.output # run firmware = Firmware(elf) avr = Avr(mcu=self.cc.mcu, f_cpu=self.cc.f_cpu) avr.load_firmware(firmware) # udpReader = UdpReader() # udp = Udp(avr) # udp.connect() # udpReader.start() simvcd = None if self.vcd: simvcd = VcdFile(avr, period=1000, filename=self.vcd) connect_pins_by_rule(''' avr.D0 ==> vcd avr.D1 ==> vcd avr.D2 ==> vcd avr.D3 ==> vcd avr.D4 ==> vcd avr.D5 ==> vcd avr.D6 ==> vcd avr.D7 ==> vcd avr.B0 ==> vcd avr.B1 ==> vcd avr.B2 ==> vcd avr.B3 ==> vcd avr.B4 ==> vcd avr.B5 ==> vcd ''', dict( avr=avr, ), vcd=simvcd, ) simvcd.start() # not working # if self.serial_in: # avr.uart.send_string(self.serial_in) avr.move_time_marker(self.timespan) while avr.time_passed() < self.timespan * 0.99: time.sleep(0.05) if simvcd: simvcd.terminate() # udpReader.terminate() log.debug('cycles=%s' % avr.cycle) log.debug('mcu time=%s' % avr.time_passed()) # time.sleep(1) self.serial_data = avr.uart.buffer self.serial = ''.join(self.serial_data) avr.terminate()
def test_background_thread(): cc = AvrGcc(mcu=mcu) cc.build('int main(){}') fw = Firmware(cc.output) avr = Avr(mcu=mcu, firmware=fw, f_cpu=8000000) eq_(avr.state, cpu_Running, "mcu is not running") avr.goto_cycle(100) eq_(avr.state, cpu_Running, "mcu is not running") avr.terminate()
def test_timer_GC(): avr = Avr(mcu='atmega88', f_cpu=1000000) callbackMock = Mock(return_value=0) t = weakref.ref(avr.timer(callbackMock, cycle=10)) gc.collect() assert_that(t(), is_(none()), "Orphan Timer didn't get garbage collected.") avr.step(100) assert_that(callbackMock.call_count, equal_to(0), "Number of IRQ callback invocations.") avr.terminate()
def test_fw_1(): cc = AvrGcc(mcu=mcu) cc.build('int main(){}') fw = Firmware(cc.output) avr = Avr(mcu=mcu, firmware=fw, f_cpu=8000000) eq_(avr.f_cpu, 8000000) eq_(avr.frequency, avr.f_cpu) eq_(avr.mcu, 'atmega48') avr.terminate()
def test_timer_cancel(): avr = Avr(mcu='atmega88', f_cpu=1000000) callbackMock = Mock(return_value=200) timer = avr.timer(callbackMock, cycle=50) avr.step(10) callbackMock.assert_not_called() timer.cancel() avr.step(1000) callbackMock.assert_not_called() avr.terminate()
def test_timer_simple(): avr = Avr(mcu='atmega88', f_cpu=8000000) # Callback method mocked out. callbackMock = Mock(return_value=0) #Schedule callback at 20uSec. # cycles = avr->frequency * (avr_cycle_count_t)usec / 1000000; timer = avr.timer(callbackMock, uSec=20) assert_that(timer.status(), close_to(8000000*20/1000000, 10), "uSec to cycles convertion") avr.step(1000) eq_(avr.state, cpu_Running, "mcu is not running") eq_(callbackMock.call_count, 1, "number of calback invocations") avr.terminate()
def test_custom_logger(): loggerMethod = Mock() #Register custom callback method for simav logs logger.init_simavr_logger(loggerMethod) avr = Avr(mcu='atmega48', f_cpu=8000000) #Let the simavr run in background until it sadly crashes on ramend avr.run() while avr.cycle < 8000 and avr.state == cpu_Running : time.sleep(0.1) # Expected: #('Starting atmega48 - flashend 0fff ramend 02ff e2end 00ff\n', 3) #('atmega48 init\n', 3) #('atmega48 reset\n', 3) #('avr_sadly_crashed\n', 1) eq_(loggerMethod.call_count, 4, "number of callback invocations") loggerMethod.assert_called_with('avr_sadly_crashed\n', 1) avr.terminate()
def test_custom_logger(): loggerMethod = Mock() #Register custom callback method for simav logs logger.init_simavr_logger(loggerMethod) avr = Avr(mcu='atmega48', f_cpu=8000000) #Let the simavr run in background until it sadly crashes on ramend avr.run() while avr.cycle < 8000 and avr.state == cpu_Running: time.sleep(0.1) # Expected: #('Starting atmega48 - flashend 0fff ramend 02ff e2end 00ff\n', 3) #('atmega48 init\n', 3) #('atmega48 reset\n', 3) #('avr_sadly_crashed\n', 1) eq_(loggerMethod.call_count, 4, "number of callback invocations") loggerMethod.assert_called_with('avr_sadly_crashed\n', 1) avr.terminate()
def test_timer_GC(): avr = Avr(mcu='atmega88', f_cpu=1000000) callbackMock = Mock(return_value=0) #Don't let avr object to keep the callback referenced. t = weakref.ref(avr.timer(callbackMock, cycle=10, keep_alive=False)) gc.collect() assert_that(t(), is_(none()), "Orphan Timer didn't get garbage collected.") avr.step(100) assert_that(callbackMock.call_count, equal_to(0), "Number of IRQ callback invocations.") #Now let avr object keep the callback alive. t = weakref.ref(avr.timer(callbackMock, cycle=110, keep_alive=True)) gc.collect() assert_that(t(), is_ (not_none()), "Avr object didn't kept Timer callback alive.") avr.step(1000) assert_that(callbackMock.call_count, equal_to(1), "Number of IRQ callback invocations.") avr.terminate() gc.collect() assert_that(t(), is_(none()), "Orphan Timer didn't get garbage collected even after Avr is terminated.")
def test_timer_reoccuring(): avr = Avr(mcu='atmega48', f_cpu=8000000) # Callback method mocked out. It will register another callback # at 200 cycles and then cancel by returning 0. callbackMock = Mock(side_effect = [200, 0]) timer = avr.timer(callbackMock) avr.step(10) eq_(avr.state, cpu_Running, "mcu is not running") callbackMock.assert_not_called() # Request first timer callback at 100 cycles timer.set_timer_cycles(100) # Run long enought to ensure callback is canceled by returning 0 on the second invocation. avr.step(1000) eq_(avr.state, cpu_Running, "mcu is not running") eq_(callbackMock.call_count, 2, "number of calback invocations") lastCallFirstArg = callbackMock.call_args[0][0] assert_that(lastCallFirstArg, close_to(200, 10), "The last cycle number received in the callback doesn't match the requested one") avr.terminate()
class Controller: def __init__(self, sock, mcu_name, freq=16000000, version=1): self.mcu_name = mcu_name self.mcu = Avr(mcu=mcu_name, f_cpu=freq) self.socket = sock self.fw_path = None self.version = version self.bind_callback_for_digit_pins(atmega_328_digit_pin_table) self.vcd = None self.connect_vcd() def upload_firmware(self, fw_path): self.fw_path = fw_path fw = Firmware(fw_path) self.mcu.load_firmware(fw) def connect_vcd(self): self.vcd = VcdFile(self.mcu, filename='out' + str(self.version)) connect_pins_by_rule(''' avr.D0 ==> vcd avr.D1 ==> vcd avr.D2 ==> vcd avr.D3 ==> vcd avr.D4 ==> vcd avr.D5 ==> vcd avr.D6 ==> vcd avr.D7 ==> vcd avr.B0 ==> vcd avr.B1 ==> vcd avr.B2 ==> vcd avr.B3 ==> vcd avr.B4 ==> vcd avr.B5 ==> vcd ''', dict(avr=self.mcu), vcd=self.vcd) def bind_callback_for_digit_pins(self, ports): def port_callback(irq, new_val): msg = "change " + self.mcu_name + ' ' + irq.name[ 0] + " " + irq.name[1] + " " + str(new_val) self.socket.send_msg(msg) callback = Mock(side_effect=port_callback) for port in ports: p = self.mcu.irq.ioport_register_notify(callback, (port[0], int(port[1:]))) p.get_irq().name = port def new_pin_val(self, port_pin, new_val): # type: ((str, int), int) -> None irq = self.mcu.irq.getioport(port_pin) avr_raise_irq(irq, new_val) def run(self): self.vcd.start() self.mcu.run() def pause(self): self.vcd.stop() self.mcu.pause() def terminate(self): if self.vcd: self.vcd.terminate() self.mcu.terminate()
try: while True: # Do multiple simavr simulation steps synchronously. # Alternatively inbuilt pysimavr background execution thread can be used. avr.step(1000) time.sleep(0.01) # Print any simavr mcu state change. if avr.state != prevState: prevState = avr.state print("Avr state: {}".format(avr.states[avr.state])) # Simavr got to a final state. Terminate the main loop since it can't proceed any further. if avr.state in (cpu_Done, cpu_Crashed): break i += 1 # Simulate button press once in a while. if i % 200 == 50: print("Press") b.press(10000) # Press with autorelease # if i % 100 == 0:b.up(); # if i % 100 == 50:b.down(); finally: avr.terminate() print("end")
def simulate(self): if not self.external_elf: elf = self.cc.output else: elf = self.external_elf # run firmware = Firmware(elf) avr = Avr(mcu=self.cc.mcu, f_cpu=self.cc.f_cpu) avr.uart.char_logger = self.serial_char_logger avr.uart.line_logger = self.serial_line_logger avr.load_firmware(firmware) # udpReader = UdpReader() # udp = Udp(avr) # udp.connect() # udpReader.start() simvcd = None if self.vcd: simvcd = VcdFile(avr, period=1000, filename=self.vcd) connect_pins_by_rule(''' avr.D0 ==> vcd avr.D1 ==> vcd avr.D2 ==> vcd avr.D3 ==> vcd avr.D4 ==> vcd avr.D5 ==> vcd avr.D6 ==> vcd avr.D7 ==> vcd avr.B0 ==> vcd avr.B1 ==> vcd avr.B2 ==> vcd avr.B3 ==> vcd avr.B4 ==> vcd avr.B5 ==> vcd ''', dict( avr=avr, ), vcd=simvcd, ) simvcd.start() # not working # if self.serial_in: # avr.uart.send_string(self.serial_in) if self.fps: dt_real = 1. / self.fps dt_mcu = dt_real * self.speed count = int(self.timespan * self.fps / self.speed) for _ in range(count): time.sleep(dt_real) avr.goto_time(self.timespan) while avr.time_passed() < self.timespan * 0.99: time.sleep(0.05) if simvcd: simvcd.terminate() # udpReader.terminate() log.debug('cycles=%s' % avr.cycle) log.debug('mcu time=%s' % avr.time_passed()) # time.sleep(1) self.serial_data = avr.uart.buffer self.serial = ''.join(self.serial_data) avr.terminate()
# Main loop. try: while True: # Do multiple simavr simulation steps synchronously. # Alternatively inbuilt pysimavr background execution thread can be used. avr.step(1000); time.sleep(0.01) # Print any simavr mcu state change. if avr.state != prevState: prevState = avr.state print("Avr state: {}".format(avr.states[avr.state])); # Simavr got to a final state. Terminate the main loop since it can't proceed any further. if avr.state in (cpu_Done, cpu_Crashed): break; i += 1 # Simulate button press once in a while. if i % 200 == 50: print("Press") b.press(10000); # Press with autorelease # if i % 100 == 0:b.up(); # if i % 100 == 50:b.down(); finally: avr.terminate() print("end")
from pysimavr.avr import Avr if __name__ == "__main__": avr = Avr(mcu="atmega48", f_cpu=8000000) print(avr.pc) avr.step(1) print(avr.pc) avr.step(1) print(avr.pc) avr.terminate()
def simulate(self): if not self.external_elf: elf = self.cc.output else: elf = self.external_elf # run firmware = Firmware(elf) avr = Avr(mcu=self.cc.mcu, f_cpu=self.cc.f_cpu) avr.uart.char_logger = self.serial_char_logger avr.uart.line_logger = self.serial_line_logger avr.load_firmware(firmware) # udpReader = UdpReader() # udp = Udp(avr) # udp.connect() # udpReader.start() simvcd = None if self.vcd: simvcd = VcdFile(avr, period=1000, filename=self.vcd) connect_pins_by_rule( ''' avr.D0 ==> vcd avr.D1 ==> vcd avr.D2 ==> vcd avr.D3 ==> vcd avr.D4 ==> vcd avr.D5 ==> vcd avr.D6 ==> vcd avr.D7 ==> vcd avr.B0 ==> vcd avr.B1 ==> vcd avr.B2 ==> vcd avr.B3 ==> vcd avr.B4 ==> vcd avr.B5 ==> vcd ''', dict(avr=avr, ), vcd=simvcd, ) simvcd.start() # not working # if self.serial_in: # avr.uart.send_string(self.serial_in) if self.fps: dt_real = 1. / self.fps dt_mcu = dt_real * self.speed count = int(self.timespan * self.fps / self.speed) for _ in range(count): time.sleep(dt_real) avr.goto_time(self.timespan) while avr.time_passed() < self.timespan * 0.99: time.sleep(0.05) if simvcd: simvcd.terminate() # udpReader.terminate() log.debug('cycles=%s' % avr.cycle) log.debug('mcu time=%s' % avr.time_passed()) # time.sleep(1) self.serial_data = avr.uart.buffer self.serial = ''.join(self.serial_data) avr.terminate()