Beispiel #1
0
    def __init__(self, avr):
        #        firmware = avr.firmware
        cycle_measure_time = 1
        self.speed = 0
        self.start = pygame.time.get_ticks()
        self.firmware_time = '??:??:??'
        self.avr = avr

        self.reload()

        def avr_state():
            try:
                return avr.states[avr.state]
            except:
                return str(avr.state)

        CompositeGame.__init__(self, [
            TextGame((lambda: "mcu=%s" % avr.mcu)),
            TextGame((lambda: "f_cpu=%s" % format_freq(avr.f_cpu))),
            TextGame((lambda: "%s (%s)" %
                      (avr.firmware.filename.name, self.firmware_time))),
            TextGame(
                (lambda: 'prog: %s bytes %s%% ' %
                 (avr.avrsize.program_bytes, avr.avrsize.program_percentage))),
            TextGame((lambda: 'mem: %s bytes %s%%' %
                      (avr.avrsize.data_bytes, avr.avrsize.data_percentage))),
            TextGame((lambda: "vcc=%sV avcc=%sV" % (avr.vcc, avr.avcc))),
            TextGame((lambda: "pc=%8d" % avr.pc)),
            TextGame((lambda: "state=%s" % avr_state())),
            TextGame((lambda: "cycle= %9d" % (avr.cycle))),
            TextGame((lambda: "mcu time=%s us" % str(1000000 * avr.cycle / avr.
                                                     f_cpu).rjust(10))),
            TextGame((lambda: "real time=%s s" % str(
                (pygame.time.get_ticks() - self.start) / 1000).rjust(3))),
            TextGame((lambda: "real speed= %fx" % (self.speed))),
        ],
                               align=1),

        def target():
            c_old = 0
            t_old = 0
            while not self._stop_thread:
                c = avr.cycle
                t = pygame.time.get_ticks()

                c_diff = c - c_old
                t_diff = t - t_old
                c_old = c
                t_old = t

                if t_diff:
                    self.speed = 1000.0 * c_diff / t_diff / avr.f_cpu

                time.sleep(cycle_measure_time)

        self._thread = threading.Thread(target=target)
        #        self._thread.daemon = 1
        self._stop_thread = False
        self._thread.start()
Beispiel #2
0
def run_sim(vcdfile='lcd.vcd', speed=0.1, fps=20, timeout=0.0, visible=1, image_file=''):
    firmware = Firmware(path(__file__).dirname() / 'lcd.elf')
    avr = Avr(firmware, f_cpu=16000000)
    lcd = Lcd(avr)
    ledrow = LedRow(avr, size=7)
    # period=1000 -> vcd error
    vcd = VcdFile(avr, period=10, filename=vcdfile)

    def state_func(i):
        return (ledrow.pinstate(i), ledrow.reset_dirty(i))
    led_game = LedRowGame(state_func=state_func,
                          labels='D4 D5 D6 D7 RS E RW'.split()
                          )
    ac = Ac(avr)
    connect_pins_by_rule('''
    avr.B0 <=> lcd.D4 -> vcd
    avr.B1 <=> lcd.D5 -> vcd
    avr.B2 <=> lcd.D6 -> vcd
    avr.B3 <=> lcd.D7 -> vcd

    avr.B4 ==> lcd.RS -> vcd
    avr.B5 ==> lcd.E  -> vcd
    avr.B6 ==> lcd.RW -> vcd
    vcd <- ac.OUT -> avr.D2

    lcd.D4 -> led.0
    lcd.D5 -> led.1
    lcd.D6 -> led.2
    lcd.D7 -> led.3

    lcd.RS -> led.4
    lcd.E  -> led.5
    lcd.RW -> led.6
                        ''',
                         dict(
                             avr=avr,
                             led=ledrow,
                             lcd=lcd,
                             ac=ac
                         ),
                         vcd=vcd,
                         )

    dev = CompositeGame([
                        CompositeGame(
                        [LcdGame(
                         lambda x, y:lcd.get_char(x, y), (20, 2)),
                         led_game,
                         ],
                        align=1),
                        InfoGame(avr),
                        ])

    scrshot_by_exit = [(dev, image_file)] if image_file else None

    AvrSimMain(
        avr, dev, vcd, speed=speed, fps=fps, visible=visible, timeout=timeout,
        scrshot_by_exit=scrshot_by_exit).run_game()
Beispiel #3
0
    def __init__(self, state_func, disp_size=None, labels=None, align=0, size='auto'):
        if disp_size is None and labels is None:
            raise ValueError('disp_size is None and labels is None')

        if disp_size is None:
            disp_size = len(labels)

        self.disp_size = disp_size
        self.leds = []
        self.state_func = state_func
        for i in xrange(self.disp_size):
            s = None
            if labels:
                if i < len(labels):
                    s = labels[i]
            led = LedGame(state_func=self._get_single_state_func(i), label=s)
            self.leds += [led]

        CompositeGame.__init__(self, self.leds, align=align, size=size)
Beispiel #4
0
def run_sim(vcdfile='ledramp.vcd',
            speed=0.1,
            fps=20,
            timeout=0.0,
            visible=1,
            image_file=''):
    firmware = Firmware(path(__file__).dirname() / 'ledramp.elf')
    avr = Avr(firmware, f_cpu=8000000, mcu='atmega48')

    vcd = VcdFile(avr, period=1000, filename=vcdfile)
    ledrow = LedRow(avr)
    connect_pins_by_rule(
        '''
                        avr.B0 ==> led.0 -> vcd
                        avr.B1 ==> led.1 -> vcd
                        avr.B2 ==> led.2 -> vcd
                        avr.B3 ==> led.3 -> vcd
                        avr.B4 ==> led.4 -> vcd
                        avr.B5 ==> led.5 -> vcd
                        avr.B6 ==> led.6 -> vcd
                        avr.B7 ==> led.7 -> vcd
                        ''',
        dict(
            avr=avr,
            led=ledrow,
        ),
        vcd=vcd,
    )

    def state_func(i):
        return (ledrow.pinstate(i), ledrow.reset_dirty(i))

    led_game = LedRowGame(state_func=state_func,
                          labels=['B' + str(x) for x in range(8)])

    dev = CompositeGame([
        led_game,
        InfoGame(avr),
    ])

    scrshot_by_exit = [(dev, image_file)] if image_file else None

    AvrSimMain(avr,
               dev,
               vcd,
               speed=speed,
               fps=fps,
               visible=visible,
               timeout=timeout,
               scrshot_by_exit=scrshot_by_exit).run_game()
Beispiel #5
0
    def __init__(self,
                 state_func,
                 disp_size=None,
                 labels=None,
                 align=0,
                 size='auto'):
        if disp_size is None and labels is None:
            raise ValueError('disp_size is None and labels is None')

        if disp_size is None:
            disp_size = len(labels)

        self.disp_size = disp_size
        self.leds = []
        self.state_func = state_func
        for i in xrange(self.disp_size):
            s = None
            if labels:
                if i < len(labels):
                    s = labels[i]
            led = LedGame(state_func=self._get_single_state_func(i), label=s)
            self.leds += [led]

        CompositeGame.__init__(self, self.leds, align=align, size=size)
Beispiel #6
0
def start():
    def func_on():
        return (1, 0)

    def func_off():
        return (0, 0)

    def func_pulse():
        return (1, 1)

    dev1 = LedGame(func_on, 'on')
    dev2 = LedGame(func_off, 'off')
    dev3 = LedGame(func_pulse, 'pulse')
    dev = CompositeGame([dev1, dev2, dev3])
    MainGame(dev).run_game()
Beispiel #7
0
def run_sim(vcdfile='spk.vcd',
            speed=0.5,
            fps=20,
            timeout=0.0,
            visible=1,
            image_file='',
            rate=11025):
    firmware = Firmware(path(__file__).dirname() / 'spk.elf')
    avr = Avr(
        firmware=firmware,
        mcu="atmega168",
        f_cpu=16000000,
    )
    ledrow = LedRow(avr, size=1)
    # period=1000 -> vcd error
    vcd = VcdFile(avr, period=10, filename=vcdfile)
    spk = Spk(avr, rate=rate, speed=speed)

    connect_pins_by_rule(
        '''
    led.0 <-- avr.B5 --> spk.IN -> vcd
                        ''',
        dict(
            avr=avr,
            spk=spk,
            led=ledrow,
        ),
        vcd=vcd,
    )

    ####################################                     )
    # GUI

    def spk_func(size):
        return spk.read()

    spk_game = SpkGame(spk_func, rate=rate)

    def state_func(i):
        return (ledrow.pinstate(i), ledrow.reset_dirty(i))

    led_game = LedRowGame(state_func=state_func, labels=['SPK'])
    dev = CompositeGame([
        CompositeGame([
            led_game,
        ], align=1),
        InfoGame(avr),
    ])

    scrshot_by_exit = [(dev, image_file)] if image_file else None

    AvrSimMain(avr,
               dev,
               vcd,
               speed=speed,
               fps=fps,
               visible=visible,
               timeout=timeout,
               scrshot_by_exit=scrshot_by_exit).run_game()

    spk_game.terminate()
Beispiel #8
0
def run_sim(vcdfile='sgm7.vcd',
            speed=0.001,
            fps=20,
            timeout=0.0,
            visible=1,
            image_file=''):
    firmware = Firmware(path(__file__).dirname() / 'sgm7.elf')
    firmware.f_cpu = 8000000
    firmware.mcu = "atmega168"
    avr = Avr(firmware)
    vcd = VcdFile(avr, period=1000, filename=vcdfile)

    ####################################################
    # ledrow
    ledrow = LedRow(avr, size=12)

    ####################################################
    # ledrow game
    def state_func_seg(i):
        return (ledrow.pinstate(i), ledrow.reset_dirty(i))

    led_game_seg = LedRowGame(state_func=state_func_seg,
                              disp_size=8,
                              labels=['B' + str(x) for x in range(8)])

    def state_func_dig(i):
        return (ledrow.pinstate(i + 8), ledrow.reset_dirty(i + 8))

    led_game_dig = LedRowGame(state_func=state_func_dig,
                              disp_size=4,
                              labels=['C' + str(x) for x in range(4)])
    ####################################################
    # sgm7
    sgm7 = Sgm7(avr, size=4)

    inv = [Inverter(avr) for x in range(4)]

    connect_pins_by_rule(
        '''
                        ledrow.0 <== avr.B0 ==> sgm7.A -> vcd
                        ledrow.1 <== avr.B1 ==> sgm7.B -> vcd
                        ledrow.2 <== avr.B2 ==> sgm7.C -> vcd
                        ledrow.3 <== avr.B3 ==> sgm7.D -> vcd
                        ledrow.4 <== avr.B4 ==> sgm7.E -> vcd
                        ledrow.5 <== avr.B5 ==> sgm7.F -> vcd
                        ledrow.6 <== avr.B6 ==> sgm7.G -> vcd
                        ledrow.7 <== avr.B7 ==> sgm7.P -> vcd

                        ledrow.8 <== avr.C0 ==> inv0.IN | inv0.OUT -> sgm7.D0 -> vcd
                        ledrow.9 <== avr.C1 ==> inv1.IN | inv1.OUT -> sgm7.D1 -> vcd
                        ledrow.10<== avr.C2 ==> inv2.IN | inv2.OUT -> sgm7.D2 -> vcd
                        ledrow.11<== avr.C3 ==> inv3.IN | inv3.OUT -> sgm7.D3 -> vcd
                        ''',
        dict(
            avr=avr,
            sgm7=sgm7,
            ledrow=ledrow,
            inv0=inv[0],
            inv1=inv[1],
            inv2=inv[2],
            inv3=inv[3],
        ),
        vcd=vcd,
    )

    ####################################################
    # sgm7 game
    def segments_func(digit_index):
        return (sgm7.digit_segments(digit_index),
                sgm7.reset_dirty(digit_index))

    sgm7_game = Sgm7Game(segments_func=segments_func, disp_size=4)

    ####################################################
    # compose game
    dev = CompositeGame([
        CompositeGame([
            sgm7_game,
            led_game_seg,
            led_game_dig,
        ], align=1),
        InfoGame(avr),
    ])

    scrshot_by_exit = [(dev, image_file)] if image_file else None

    AvrSimMain(avr,
               dev,
               vcd,
               speed=speed,
               fps=fps,
               visible=visible,
               timeout=timeout,
               scrshot_by_exit=scrshot_by_exit).run_game()
Beispiel #9
0
def arduino_sim(
    elf='',
    mcu='atmega328',
    f_cpu=16000000,
    vcdfile='arduino.vcd',
    speed=0.5,
    fps=20,
    timeout=0.0,
    visible=1,
    image_file='',
    rate=11025,
    buttons_enable=1,
    vcd_enable=0,
    spk_enable=0,
    #            udp_enable=1,
    avcc=5000,
    vcc=5000,
    code=None,
):
    '''

    MCU:
     - atmega168 OK
     - atmega328p OK
     - atmega2560 NO
     - atmega1280 NO

    :param mcu:
    :param avcc: AVcc  in mV
    :param vcc: Vcc  in mV

    '''

    if code and pyavrutils:
        cc = pyavrutils.Arduino()
        cc.build(code)
        elf = cc.output

    if not elf:
        elf = find_elf()
    firmware = Firmware(elf)
    avr = Avr(mcu=mcu, f_cpu=f_cpu, vcc=vcc / 1000.0, avcc=avcc / 1000.0)
    avr.load_firmware(firmware)

    #    udpReader = UdpReader()

    #    if udp_enable:
    #        udp = Udp(avr)
    #        udp.connect()
    #        udpReader.start()

    lcd = Lcd(avr)

    vcd = VcdFile(avr, period=1000, filename=vcdfile) if vcd_enable else None
    ledrow = LedRow(avr, size=14)
    buttons = [Button(avr, pullup=0)
               for x in range(14)] if buttons_enable else 14 * [None]
    spk = Spk(avr, rate=rate, speed=speed) if spk_enable else None

    connect_pins_by_rule(
        '''
                        but0 .OUT ==> avr.D0 ==> dig.0  -> vcd
                        but1 .OUT ==> avr.D1 ==> dig.1  -> vcd
                        but2 .OUT ==> avr.D2 ==> dig.2  -> vcd
                        but3 .OUT ==> avr.D3 ==> dig.3  -> vcd
                        but4 .OUT ==> avr.D4 ==> dig.4  -> vcd
                        but5 .OUT ==> avr.D5 ==> dig.5  -> vcd
                        but6 .OUT ==> avr.D6 ==> dig.6  -> vcd
                        but7 .OUT ==> avr.D7 ==> dig.7  -> vcd

                        but8 .OUT ==> avr.B0 ==> dig.8  -> vcd
                        but9 .OUT ==> avr.B1 ==> dig.9  -> vcd
                        but10.OUT ==> avr.B2 ==> dig.10 -> vcd
                        but11.OUT ==> avr.B3 ==> dig.11 -> vcd
                        but12.OUT ==> avr.B4 ==> dig.12 -> vcd
                        but13.OUT ==> avr.B5 ==> dig.13 -> vcd

                        dig.13 --> spk.IN -> vcd

                        dig.5 <=> lcd.D4 -> vcd
                        dig.4 <=> lcd.D5 -> vcd
                        dig.3 <=> lcd.D6 -> vcd
                        dig.2 <=> lcd.D7 -> vcd

                        dig.12 ==> lcd.RS -> vcd
                        dig.11 ==> lcd.RW -> vcd
                        dig.10 ==> lcd.E  -> vcd
                        ''',
        dict(avr=avr,
             dig=ledrow,
             lcd=lcd,
             spk=spk,
             **dict([('but' + str(i), b) for i, b in enumerate(buttons)])),
        vcd=vcd,
    )
    #################
    # GUI
    #################
    if spk_enable:

        def spk_func(size):
            return spk.read()

        spk_game = SpkGame(spk_func, rate=rate)

    def state_func(i):
        return (ledrow.pinstate(i), ledrow.reset_dirty(i))

    led_game = LedRowGame(
        state_func=state_func,
        labels=[str(x) for x in range(14)],
        align=1,
    )

    but_guis = [
        ButtonGame(
            label=label,
            shortcut=shortcut,
            hook=dict(up=x.up, down=x.down) if x else {},
            size=(50, 30),
        ) for x, label, shortcut in zip(
            buttons,
            '0 1 2 3 4 5 6 7 8 9 10 11 12 13'.split(),
            '0 1 2 3 4 5 6 7 8 9 a b c d'.split(),
        )
    ]
    info = InfoGame(avr)

    def reload_firmware():
        firmware = Firmware(find_elf())
        avr.load_firmware(firmware)
        lcd.reset()
        info.reload()

    class MyFloat(object):
        def __init__(self, value=0.0):
            self.value = value

        def __float__(self):
            return float(self.value)

        def inc(self):
            self.value *= 10.0

        def dec(self):
            self.value /= 10.0

    speed = MyFloat(speed)

    #    def udp_read():
    #        if not hasattr(udp_read, 'display'):
    #            udp_read.display = ''
    #        if not hasattr(udp_read, 'lastline'):
    #            udp_read.lastline = ''
    #        s = udpReader.read()
    #        if s:
    #            sys.stdout.write(s)
    #            udp_read.lastline += s
    #            udp_read.lastline = lastline(udp_read.lastline)
    #            udp_read.display = udp_read.lastline.replace(
    #                '\n', '\\n').replace('\r', '\\r')
    #        return  udp_read.display
    def uart_read():
        return avr.uart.last_line.replace('\n', '\\n').replace('\r', '\\r')

    dev = CompositeGame([
        CompositeGame([
            led_game,
            CompositeGame(but_guis, align=1),
        ], align=0), info,
        CompositeGame([
            CompositeGame([
                ButtonGame(label='reload',
                           shortcut='r',
                           hook=dict(down=reload_firmware)),
                ButtonGame(
                    label='speed up', shortcut='+', hook=dict(down=speed.inc)),
                ButtonGame(label='speed down',
                           shortcut='-',
                           hook=dict(down=speed.dec)),
                TextGame((lambda: "speed set= %fx" % float(speed))),
            ],
                          align=1),
            LcdGame(lambda x, y: lcd.get_char(x, y), (16, 2)),
            TextGame((lambda: 'ser=' + uart_read())),
        ],
                      align=1)
    ])

    scrshot_by_exit = [(dev, image_file)] if image_file else None

    class ArduinoMain(AvrSimMain):
        bufpos = 0

        def cb_loop(self):
            AvrSimMain.cb_loop(self)
#            if len(udpReader.buffer) > self.bufpos:
#                sys.stdout.write(''.join(udpReader.buffer[self.bufpos:]))
#                self.bufpos = len(udpReader.buffer)

    sim = ArduinoMain(avr,
                      dev,
                      vcd,
                      speed=speed,
                      fps=fps,
                      visible=visible,
                      timeout=timeout,
                      scrshot_by_exit=scrshot_by_exit)
    sim.run_game()

    time.sleep(1)
    if spk_enable:
        spk_game.terminate()
Beispiel #10
0
 def exit(self):
     self._stop_thread = 1
     CompositeGame.exit(self)
Beispiel #11
0
    def __init__(self, avr):
#        firmware = avr.firmware
        cycle_measure_time = 1
        self.speed = 0
        self.start = pygame.time.get_ticks()
        self.firmware_time = '??:??:??'
        self.avr = avr

        self.reload()

        def avr_state():
            try:
                return avr.states[avr.state]
            except:
                return str(avr.state)

        CompositeGame.__init__(self,
                               [
                               TextGame((lambda: "mcu=%s" % avr.mcu)),

                               TextGame((lambda:
                                         "f_cpu=%s" % format_freq(avr.f_cpu))),
                               TextGame((lambda: "%s (%s)" % (
                                         avr.firmware.filename.name, self.firmware_time))),
                               TextGame((lambda: 'prog: %s bytes %s%% ' % (avr.avrsize.program_bytes, avr.avrsize.program_percentage))),
                               TextGame((lambda: 'mem: %s bytes %s%%' % (
                                         avr.avrsize.data_bytes, avr.avrsize.data_percentage))),
                               TextGame((lambda: "vcc=%sV avcc=%sV" %
                                       (avr.vcc, avr.avcc))),
                               TextGame((lambda: "pc=%8d" % avr.pc)),
                               TextGame((lambda: "state=%s" % avr_state())),
                               TextGame((lambda: "cycle= %9d" % (avr.cycle))),
                               TextGame((lambda: "mcu time=%s us" %
                                         str(
                                             1000000 * avr.cycle / avr.f_cpu).rjust(10))),
                               TextGame((lambda: "real time=%s s" % str((
                                                                        pygame.time.get_ticks() - self.start) / 1000).rjust(3))),
                               TextGame(
                               (lambda: "real speed= %fx" % (self.speed))),
                               ], align=1),

        def target():
            c_old = 0
            t_old = 0
            while not self._stop_thread:
                c = avr.cycle
                t = pygame.time.get_ticks()

                c_diff = c - c_old
                t_diff = t - t_old
                c_old = c
                t_old = t

                if t_diff:
                    self.speed = 1000.0 * c_diff / t_diff / avr.f_cpu

                time.sleep(cycle_measure_time)

        self._thread = threading.Thread(target=target)
#        self._thread.daemon = 1
        self._stop_thread = False
        self._thread.start()
Beispiel #12
0
 def exit(self):
     self._stop_thread = 1
     CompositeGame.exit(self)