Class: AVR::Device

Inherits:
Object
  • Object
show all
Extended by:
T::Helpers, T::Sig
Defined in:
lib/avr/device.rb,
lib/avr/device/atmel_atmega328p.rb

Direct Known Subclasses

Atmel_ATmega328p

Defined Under Namespace

Classes: Atmel_ATmega328p

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Device

Returns a new instance of Device.



111
112
113
114
115
116
117
118
119
120
121
122
123
124
 
# File 'lib/avr/device.rb', line 111

def initialize
  @cpu = T.let(CPU.new(self), CPU)
  @flash = T.let(Flash.new(flash_size), Flash)
  @eeprom = T.let(EEPROM.new(eeprom_size, cpu), EEPROM)

  @system_clock = T.let(Clock.new('system'), Clock)
  @system_clock.push_sink(cpu.clock)

  @oscillator = T.let(Oscillator.new('oscillator'), Oscillator)
  @oscillator.push_sink(system_clock)

  @data_memory_map_by_address = T.let(nil, T.nilable(T::Hash[Integer, Symbol]))
  @io_registers = T.let(nil, T.nilable(T::Array[T.nilable(Symbol)]))
end

Instance Attribute Details

#cpu ⇒ Object (readonly)

Returns the value of attribute cpu.



96
97
98
 
# File 'lib/avr/device.rb', line 96

def cpu
  @cpu
end

#eeprom ⇒ Object (readonly)

Returns the value of attribute eeprom.



108
109
110
 
# File 'lib/avr/device.rb', line 108

def eeprom
  @eeprom
end

#flash ⇒ Object (readonly)

Returns the value of attribute flash.



105
106
107
 
# File 'lib/avr/device.rb', line 105

def flash
  @flash
end

#oscillator ⇒ Object (readonly)

Returns the value of attribute oscillator.



102
103
104
 
# File 'lib/avr/device.rb', line 102

def oscillator
  @oscillator
end

#system_clock ⇒ Object (readonly)

Returns the value of attribute system_clock.



99
100
101
 
# File 'lib/avr/device.rb', line 99

def system_clock
  @system_clock
end

Instance Method Details

#data_memory_map ⇒ Object 



20
 
# File 'lib/avr/device.rb', line 20

def data_memory_map; end

#data_memory_map_by_address ⇒ Object 



59
60
61
62
63
 
# File 'lib/avr/device.rb', line 59

def data_memory_map_by_address
  @data_memory_map_by_address ||= data_memory_map.each_with_object({}) do |(n, a), h|
    h[a] = n unless n =~ /^_/
  end
end

#eeprom_size ⇒ Object 



17
 
# File 'lib/avr/device.rb', line 17

def eeprom_size; end

#ext_io_register_count ⇒ Object 



44
 
# File 'lib/avr/device.rb', line 44

def ext_io_register_count; end

#ext_io_register_start ⇒ Object 



41
 
# File 'lib/avr/device.rb', line 41

def ext_io_register_start; end

#flash_size ⇒ Object 



14
 
# File 'lib/avr/device.rb', line 14

def flash_size; end

#interrupt_vector_map ⇒ Object 



53
 
# File 'lib/avr/device.rb', line 53

def interrupt_vector_map; end

#io_register_count ⇒ Object 



38
 
# File 'lib/avr/device.rb', line 38

def io_register_count; end

#io_register_start ⇒ Object 



35
 
# File 'lib/avr/device.rb', line 35

def io_register_start; end

#io_registers ⇒ Object 



66
67
68
69
70
 
# File 'lib/avr/device.rb', line 66

def io_registers
  @io_registers ||= (0...io_register_count).map do |i|
    data_memory_map_by_address[io_register_start + i]
  end
end

#port_map ⇒ Object 



56
 
# File 'lib/avr/device.rb', line 56

def port_map; end

#ram_end ⇒ Object 



50
 
# File 'lib/avr/device.rb', line 50

def ram_end; end

#ram_start ⇒ Object 



47
 
# File 'lib/avr/device.rb', line 47

def ram_start; end

#register_bit_names_map ⇒ Object 



29
 
# File 'lib/avr/device.rb', line 29

def register_bit_names_map; end

#register_count ⇒ Object 



26
 
# File 'lib/avr/device.rb', line 26

def register_count; end

#register_start ⇒ Object 



23
 
# File 'lib/avr/device.rb', line 23

def register_start; end

#sequential_interrupt_vectors(interrupts) ⇒ Object 



91
92
93
 
# File 'lib/avr/device.rb', line 91

def sequential_interrupt_vectors(interrupts)
  interrupts.each_with_index.each_with_object({}) { |(name, i), h| h[name.to_sym] = i * 2 }
end

#sram_size ⇒ Object 



11
 
# File 'lib/avr/device.rb', line 11

def sram_size; end

#standard_port(port) ⇒ Object 



73
74
75
76
77
78
79
 
# File 'lib/avr/device.rb', line 73

def standard_port(port)
  {
    pin: data_memory_map["PIN#{port}".to_sym],
    ddr: data_memory_map["DDR#{port}".to_sym],
    port: data_memory_map["PORT#{port}".to_sym],
  }
end

#standard_ports(ports) ⇒ Object 



86
87
88
 
# File 'lib/avr/device.rb', line 86

def standard_ports(ports)
  ports.each_with_object({}) { |m, h| h[m] = standard_port(m) }
end

#trace_all ⇒ Object 



238
239
240
241
242
243
244
245
246
247
 
# File 'lib/avr/device.rb', line 238

def trace_all
  trace_cpu
  trace_sram
  trace_flash
  trace_eeprom
  trace_sreg
  trace_registers
  trace_status_pre_tick
  trace_status_post_tick
end

#trace_cpu ⇒ Object 



127
128
129
130
131
132
133
134
 
# File 'lib/avr/device.rb', line 127

def trace_cpu
  cpu.trace do |instruction|
    puts '*** %20s: %s' % [
      'INSTRUCTION TRACE',
      instruction,
    ]
  end
end

#trace_eeprom ⇒ Object 



201
202
203
204
205
206
207
208
209
210
 
# File 'lib/avr/device.rb', line 201

def trace_eeprom
  eeprom.watch do |memory_byte, old_value, new_value|
    puts '*** %20s: %12s: %4s -> %4s' % [
      'MEMORY TRACE',
      '%s[%04x]' % [memory_byte.memory.name, memory_byte.address],
      memory_byte.format % old_value,
      memory_byte.format % new_value,
    ]
  end
end

#trace_flash ⇒ Object 



189
190
191
192
193
194
195
196
197
198
 
# File 'lib/avr/device.rb', line 189

def trace_flash
  flash.watch do |memory_byte, old_value, new_value|
    puts '*** %20s: %12s: %4s -> %4s' % [
      'MEMORY TRACE',
      '%s[%04x]' % [memory_byte.memory.name, memory_byte.address],
      memory_byte.format % old_value,
      memory_byte.format % new_value,
    ]
  end
end

#trace_registers ⇒ Object 



137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
 
# File 'lib/avr/device.rb', line 137

def trace_registers
  register_addresses = {}
  cpu.registers.registers.each do |_name, register|
    case register
    when MemoryByteRegister
      register_addresses[register.memory_byte.address] ||= []
      register_addresses[register.memory_byte.address] << register
    when RegisterPair
      register_addresses[register.l.memory_byte.address] ||= []
      register_addresses[register.l.memory_byte.address] << register
      register_addresses[register.h.memory_byte.address] ||= []
      register_addresses[register.h.memory_byte.address] << register
    end
  end
  cpu.sram.watch do |memory_byte, old_value, _new_value|
    registers = register_addresses[memory_byte.address]
    registers&.each do |register|
      puts '*** %20s: %12s: %4s -> %4s' % [
        'REGISTER TRACE',
        register.name,
        register.is_a?(MemoryByteRegister) ? register.format % old_value : '',
        register.format % register.value,
      ]
    end
  end
end

#trace_sram ⇒ Object 



177
178
179
180
181
182
183
184
185
186
 
# File 'lib/avr/device.rb', line 177

def trace_sram
  cpu.sram.watch do |memory_byte, old_value, new_value|
    puts '*** %20s: %12s: %4s -> %4s' % [
      'MEMORY TRACE',
      '%s[%04x]' % [memory_byte.memory.name, memory_byte.address],
      memory_byte.format % old_value,
      memory_byte.format % new_value,
    ]
  end
end

#trace_sreg ⇒ Object 



165
166
167
168
169
170
171
172
173
174
 
# File 'lib/avr/device.rb', line 165

def trace_sreg
  cpu.sram.watch do |memory_byte, old_value, new_value|
    if memory_byte.address == cpu.sreg.memory_byte.address
      puts '*** %20s: %s' % [
        'SREG TRACE',
        cpu.sreg.diff_values(old_value, new_value),
      ]
    end
  end
end

#trace_status_post_tick ⇒ Object 



226
227
228
229
230
231
232
233
234
235
 
# File 'lib/avr/device.rb', line 226

def trace_status_post_tick
  oscillator.push_sink(
    Clock::Sink.new('post-execution status') do
      puts
      puts 'POST-EXECUTION STATUS'
      puts '*********************'
      cpu.print_status
    end
  )
end

#trace_status_pre_tick ⇒ Object 



213
214
215
216
217
218
219
220
221
222
223
 
# File 'lib/avr/device.rb', line 213

def trace_status_pre_tick
  oscillator.unshift_sink(
    Clock::Sink.new('pre-execution status') do
      puts
      puts
      puts 'PRE-EXECUTION STATUS'
      puts '********************'
      cpu.print_status
    end
  )
end

#word_register_map ⇒ Object 



32
 
# File 'lib/avr/device.rb', line 32

def word_register_map; end