n65 0.5.0 → 1.0.0

data/everdrive_transfer/everdrive.rb

@@ -0,0 +1,175 @@
+#!/usr/bin/env ruby
+
+require 'libusb'
+require 'date'
+
+class EverdriveIO
+  class DeviceNotFound < StandardError; end
+
+  def initialize(vendor, product)
+    @device = find_device(vendor, product)
+    @input, @output = find_bulk_endpoints(device)
+    @handle = device.open
+    handle.claim_interface(input.interface)
+  end
+
+  def inspect
+    "#<#{self.class.name}: #{device.inspect}>"
+  end
+
+  def close
+    handle.close
+  end
+
+  def read(length)
+    handle.bulk_transfer(endpoint: input, dataIn: length)
+  end
+
+  def write(data)
+    handle.bulk_transfer(endpoint: output, dataOut: data)
+  end
+
+  def read_u8
+    read(1).ord
+  end
+
+  def read_u16
+    read(2).unpack('S').first
+  end
+
+  def read_u32
+    read(4).unpack('L').first
+  end
+
+  def write_u8(u8)
+    write(
+      (u8 & 0xff).chr
+    )
+  end
+
+  def write_u16(u16)
+    write(
+      [
+        (u16 & 0x00ff),
+        (u16 & 0xff00) >> 8
+      ].pack('cc')
+    )
+  end
+
+  def write_u32(u32)
+    write(
+      [
+        (u32 & 0x000000ff),
+        (u32 & 0x0000ff00) >> 8,
+        (u32 & 0x00ff0000) >> 32,
+        (u32 & 0xff000000) >> 24,
+      ].pack('cccc')
+    )
+  end
+
+  def write_string(string)
+    write_u16(string.length)
+    write(string)
+  end
+
+  private
+
+  attr_reader :input, :output, :handle, :device
+
+  def find_device(vendor, product)
+    LIBUSB::Context.new.devices(idVendor: vendor, idProduct: product).first.tap do |device|
+      raise(DeviceNotFound) if device.nil?
+    end
+  end
+
+  def find_bulk_endpoints(device)
+    [
+      device.endpoints.find { |ep| ep.transfer_type == :bulk && ep.direction == :in },
+      device.endpoints.find { |ep| ep.transfer_type == :bulk && ep.direction == :out }
+    ]
+  end
+end
+
+
+class Everdrive
+  VENDOR = 0x0483
+  PRODUCT = 0x5740
+  STATUS_OK = 0xa500
+
+  FAT_WRITE = 0x02
+  FAT_OPEN_ALWAYS = 0x10
+
+  CMD_F_FCLOSE = 0xCE;
+  CMD_F_FOPN = 0xC9
+  CMD_F_FWR = 0xCC
+  CMD_RTC_GET = 0x14;
+  CMD_STATUS = 0x10
+
+
+  def initialize
+    @everdrive = EverdriveIO.new(VENDOR, PRODUCT)
+    p status_ok?
+  end
+
+  def inspect
+    "#<#{self.class.name}: #{@everdrive.inspect}>"
+  end
+
+  def status_ok?
+    everdrive.write(make_command(CMD_STATUS))
+    everdrive.read_u16 == STATUS_OK
+  end
+
+  def get_realtime_clock
+    everdrive.write(make_command(CMD_RTC_GET))
+    rtc = everdrive.read(6)
+
+    ary = rtc.split('').map{|c| ('%x' % c.ord).to_i }
+    DateTime.new(ary[0] + 2000, ary[1], ary[2], ary[3], ary[4], ary[5])
+  end
+
+  def test_write_file
+    filename = '000-test.nes'
+    File.open(filename, 'rb') do |fp|
+      contents = fp.read
+      p file_open(filename, FAT_OPEN_ALWAYS | FAT_WRITE)
+      p file_write(contents, 0, contents.length)
+      p file_close
+    end
+  end
+
+  private
+
+  attr_reader :everdrive
+
+  def file_open(filename, mode)
+    puts 'file_open'
+    everdrive.write(make_command(CMD_F_FOPN))
+    everdrive.write_u8(mode)
+    everdrive.write_string('000-test.nes')
+    status_ok?
+  end
+
+  def file_write(data, notsure, length)
+    puts 'file_write'
+    everdrive.write(make_command(CMD_F_FWR))
+    everdrive.write_u32(data.length)
+    everdrive.write(data)
+    # other stuff txdataack instead, pay attention to blocksizes
+    status_ok?
+  end
+
+  def file_close
+    puts 'file_close'
+    everdrive.write(make_command(CMD_F_FCLOSE))
+    status_ok?
+  end
+
+  def make_command(command_code)
+    data = ['+', '+'.ord ^ 0xff, command_code, command_code ^ 0xff].map { |b| (b.ord & 0xff).chr }.join
+  end
+end
+
+everdrive = Everdrive.new
+p everdrive.get_realtime_clock
+# p everdrive.test_write_file

data/examples/pulse_chord.asm

@@ -37,7 +37,7 @@
   sei                   ; SEt Interrupt (Disables them)
   cld                   ; CLear Decimal Mode
 
-  ldx #$ff              
+  ldx #$ff
   txs                   ; Set the stack pointer
 
   ldx #$00

data/examples/scales.asm

@@ -0,0 +1,182 @@
+.ines {"prog": 1, "char": 0, "mapper": 0, "mirror": 0}
+.inc <nes.sym>
+
+.segment prog 0
+
+;;  SRAM Variables
+.org $0000
+.scope audio
+  .space timer 1
+  .space next_note 1
+  .space note_frequency 2
+.
+
+;;  Interrupt vectors
+.org $FFFA
+.dw vblank
+.dw main
+.dw irq
+
+
+.org $C000
+.scope main
+  sei
+  cld
+
+  ;;  Setup the stack
+  ldx #$ff
+  txs
+
+  ;;  Disable rendering, reset APU
+  ldx #$00
+  stx nes.ppu.control
+  stx nes.ppu.mask
+  jsr zero_apu
+
+  .scope
+    wait_vblank:
+      bit nes.ppu.status
+      bpl wait_vblank
+  .
+
+  clear_ram:
+    lda #$00
+    sta $00, x
+    sta $100, x
+    sta $300, x
+    sta $400, x
+    sta $500, x
+    sta $600, x
+    sta $700, x
+    lda #$ff
+    sta $200, x
+    inx
+    bne clear_ram
+
+  .scope
+    wait_vblank:
+      bit nes.ppu.status
+      bpl wait_vblank
+  .
+
+  jsr initialize
+
+  forever:
+    jmp forever
+  rti
+.
+
+
+;;  Zero the APU
+.scope zero_apu
+  lda #$00
+  ldx #$00
+  loop:
+    sta $4000, x
+    inx
+    cpx $18
+    bne loop
+  rts
+.
+
+
+;;  Initialize PPU and APU
+.scope initialize
+  lda #%00000011
+  sta nes.apu.channel_enable
+
+  ;  Reenable interrupts, Turn Vblank back on
+  lda #%10000000
+  sta nes.ppu.control
+
+  ;  Initialize the audio structure
+  lda #$00
+  sta audio.timer zp
+  lda #$30
+  sta audio.next_note zp
+
+  cli
+  rts
+.
+
+
+;;  Keep time via 60fps vblank
+.scope vblank
+  ;  Update the audio timer so it resets every 64 frames
+  ldx audio.timer zp
+  inx
+  txa
+  and #%00000011
+  sta audio.timer zp
+  bne return
+
+  ;  Play the next note on reset
+  lda audio.next_note zp
+  cmp #$80
+  bmi continue
+  lda #$30
+
+  continue:
+  jsr play_note
+  sta audio.next_note zp
+  inc audio.next_note zp
+
+  return:
+  rti
+.
+
+
+;;  Hi and lo byte tables for note frequencies
+.scope midi_notes
+  .scope hi
+    .bytes $35, $32, $2f, $2c, $2a, $28, $25, $23, $21, $1f, $1d, $1c, $1a, $19, $17, $16
+    .bytes $15, $14, $12, $11, $10, $0f, $0e, $0e, $0d, $0c, $0b, $0b, $0a, $0a, $09, $08
+    .bytes $08, $07, $07, $07, $06, $06, $05, $05, $05, $05, $04, $04, $04, $03, $03, $03
+    .bytes $03, $03, $02, $02, $02, $02, $02, $02, $02, $01, $01, $01, $01, $01, $01, $01
+    .bytes $01, $01, $01, $01, $01, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
+    .bytes $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
+    .bytes $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
+    .bytes $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
+  .
+  .scope lo
+    .bytes $71, $71, $9c, $f0, $6a, $09, $ca, $ab, $aa, $c6, $fe, $4f, $b8, $38, $ce, $78
+    .bytes $35, $04, $e4, $d5, $d5, $e3, $fe, $27, $5b, $9c, $e6, $3b, $9a, $01, $72, $ea
+    .bytes $6a, $f1, $7f, $13, $ad, $4d, $f3, $9d, $4c, $00, $b8, $74, $34, $f8, $bf, $89
+    .bytes $56, $26, $f9, $ce, $a6, $80, $5c, $3a, $1a, $fb, $df, $c4, $ab, $93, $7c, $67
+    .bytes $52, $3f, $2d, $1c, $0c, $fd, $ef, $e1, $d5, $c9, $bd, $b3, $a9, $9f, $96, $8e
+    .bytes $86, $7e, $77, $70, $6a, $64, $5e, $59, $54, $4f, $4b, $46, $42, $3f, $3b, $38
+    .bytes $34, $31, $2f, $2c, $29, $27, $25, $23, $21, $1f, $1d, $1b, $1a, $18, $17, $15
+    .bytes $14, $13, $12, $11, $10, $0f, $0e, $0d, $0c, $0c, $0b, $0a, $0a, $09, $08, $08
+  .
+.
+
+
+;;  Play midi note held in A
+.scope play_note
+  pha
+  tax
+  lda #%10011111
+  sta nes.apu.pulse1.control
+
+  ;  Get the low byte of the timer
+  ldy midi_notes.lo, x
+  sty nes.apu.pulse1.ft
+  sty audio.note_frequency+1 zp
+
+  ;  Get the high 3 bits of the timer
+  ldy midi_notes.hi, x
+  tya
+  and #%00000111
+  ora #%11111000
+  sta nes.apu.pulse1.ct
+  sta audio.note_frequency zp
+
+  pla
+  rts
+.
+
+
+;;  IRQ, we are not using
+.scope irq
+  rti
+.

data/lib/n65/directives/ascii.rb

@@ -1,42 +1,27 @@
+# frozen_string_literal: true
+
 require_relative '../instruction_base'
 
 module N65
-
-
-  ####
-  ##  This directive to include bytes
+  # This directive to include bytes
   class ASCII < InstructionBase
-
-
-    ####
-    ##  Try to parse an incbin directive
     def self.parse(line)
       match_data = line.match(/^\.ascii\s+"([^"]+)"$/)
       return nil if match_data.nil?
+
       ASCII.new(match_data[1])
     end
 
-
-    ####
-    ##  Initialize with filename
     def initialize(string)
       @string = string
     end
 
-
-    ####
-    ##  Execute on the assembler
     def exec(assembler)
       assembler.write_memory(@string.bytes)
     end
 
-
-    ####
-    ##  Display
     def to_s
       ".ascii \"#{@string}\""
     end
-
   end
-
 end

data/lib/n65/directives/bytes.rb

@@ -1,27 +1,21 @@
+# frozen_string_literal: true
+
 require_relative '../instruction_base'
-require_relative '../regexes.rb'
+require_relative '../regexes'
 
 module N65
-
-
-  ####
-  ##  This directive to include bytes
+  # This directive to include bytes
   class Bytes < InstructionBase
-
-    ####  Custom Exceptions
     class InvalidByteValue < StandardError; end
 
-
-    ####
-    ##  Try to parse an incbin directive
+    # Try to parse an incbin directive
     def self.parse(line)
       match_data = line.match(/^\.bytes\s+(.+)$/)
       return nil if match_data.nil?
 
       bytes_array = match_data[1].split(',').map do |byte_string|
-
-        ##  Does byte_string represent a numeric literal, or is it a symbol?
-        ##  In numeric captures $2 is always binary, $1 is always hex
+        # Does byte_string represent a numeric literal, or is it a symbol?
+        # In numeric captures $2 is always binary, $1 is always hex
 
         case byte_string.strip
         when Regexp.new("^#{Regexes::Num8}$")
@@ -30,41 +24,36 @@ module N65
         when Regexp.new("^#{Regexes::Num16}$")
           value = $2.nil? ? $1.to_i(16) : $2.to_i(2)
 
-          ##  Break value up into two bytes
+          # Break value up into two bytes
           high = (0xff00 & value) >> 8
           low  = (0x00ff & value)
           [low, high]
         when Regexp.new("^#{Regexes::Sym}$")
           $1
         else
-          fail(InvalidByteValue, byte_string)
+          raise(InvalidByteValue, byte_string)
         end
       end.flatten
 
       Bytes.new(bytes_array)
     end
 
-
-    ####
-    ##  Initialize with filename
+    # Initialize with a byte array
     def initialize(bytes_array)
       @bytes_array = bytes_array
     end
 
-
-    ####
-    ##  Execute on the assembler
+    # Execute on the assembler
     def exec(assembler)
-
       promise = assembler.with_saved_state do |saved_assembler|
         @bytes_array.map! do |byte|
           case byte
-          when Fixnum
+          when Integer
             byte
           when String
-            value = saved_assembler.symbol_table.resolve_symbol(byte)
+            saved_assembler.symbol_table.resolve_symbol(byte)
           else
-            fail(InvalidByteValue, byte)
+            raise(InvalidByteValue, byte)
           end
         end
         saved_assembler.write_memory(@bytes_array)
@@ -73,30 +62,26 @@ module N65
       begin
         promise.call
       rescue SymbolTable::UndefinedSymbol
-        ##  Write the bytes but assume a zero page address for all symbols
-        ##  And just write 0xDE for a placeholder
+        # Write the bytes but assume a zero page address for all symbols
+        # And just write 0xDE for a placeholder
         placeholder_bytes = @bytes_array.map do |byte|
           case bytes
-          when Fixnum
+          when Integer
             byte
           when String
             0xDE
           else
-            fail(InvalidByteValue, byte)
+            raise(InvalidByteValue, byte)
           end
         end
         assembler.write_memory(placeholder_bytes)
-        return promise
+        promise
       end
     end
 
-
-    ####
-    ##  Display, I don't want to write all these out
+    # Display, I don't want to write all these out
     def to_s
       ".bytes (#{@bytes_array.length})"
     end
-
   end
-
 end

data/lib/n65/directives/dw.rb

@@ -1,25 +1,21 @@
+# frozen_string_literal: true
+
 require_relative '../instruction_base'
 
 module N65
-
-
-  ####
-  ##  This directive instruction can include a binary file
+  # This directive instruction can include a binary file
   class DW < InstructionBase
-
-    ####
-    ##  Try to parse a dw directive
+    # Try to parse a dw directive
     def self.parse(line)
-
-      ##  Maybe it is a straight up bit of hex
+      # Maybe it is a straight up bit of hex
       match_data = line.match(/^\.dw\s+\$([0-9A-F]{1,4})$/)
       unless match_data.nil?
         word = match_data[1].to_i(16)
         return DW.new(word)
       end
 
-      ##  Or maybe it points to a symbol
-      match_data = line.match(/^\.dw\s+([A-Za-z_][A-Za-z0-9_\.]+)/)
+      # Or maybe it points to a symbol
+      match_data = line.match(/^\.dw\s+([A-Za-z_][A-Za-z0-9_.]+)/)
       unless match_data.nil?
         symbol = match_data[1]
         return DW.new(symbol)
@@ -27,60 +23,50 @@ module N65
       nil
     end
 
-
-    ####
-    ##  Initialize with filename
+    #  Initialize with filename
     def initialize(value)
       @value = value
     end
 
-
-    ####
-    ##  Execute on the assembler, now in this case value may
-    ##  be a symbol that needs to be resolved, if so we return
-    ##  a lambda which can be executed later, with the promise
-    ##  that that symbol will have then be defined
-    ##  This is a little complicated, I admit.
+    # Execute on the assembler, now in this case value may
+    # be a symbol that needs to be resolved, if so we return
+    # a lambda which can be executed later, with the promise
+    # that that symbol will have then be defined
+    # This is a little complicated, I admit.
     def exec(assembler)
-
       promise = assembler.with_saved_state do |saved_assembler|
         value = saved_assembler.symbol_table.resolve_symbol(@value)
         bytes = [value & 0xFFFF].pack('S').bytes
         saved_assembler.write_memory(bytes)
       end
 
-
-      ##  Try to execute it now, or setup the promise to return
+      # Try to execute it now, or setup the promise to return
       case @value
-      when Fixnum
+      when Integer
         bytes = [@value & 0xFFFF].pack('S').bytes
         assembler.write_memory(bytes)
       when String
         begin
           promise.call
         rescue SymbolTable::UndefinedSymbol
-          ##  Must still advance PC before returning promise, so we'll write
-          ##  a place holder value of 0xDEAD
+          # Must still advance PC before returning promise, so we'll write
+          # a place holder value of 0xDEAD
           assembler.write_memory([0xDE, 0xAD])
-          return promise
+          promise
         end
       else
-        fail("Uknown argument in .dw directive")
+        raise('Uknown argument in .dw directive')
       end
     end
 
-
-    ####
-    ##  Display
+    # Display
     def to_s
       case @value
       when String
         ".dw #{@value}"
-      when Fixnum
-        ".dw $%4.X" % @value
+      when Integer
+        '.dw $%4.X' % @value
       end
     end
-
   end
-
 end

data/lib/n65/directives/enter_scope.rb

@@ -1,55 +1,39 @@
+# frozen_string_literal: true
+
 require_relative '../instruction_base'
 
 module N65
-
-
-  ####
-  ##  This directive to include bytes
+  # This directive to include bytes
   class EnterScope < InstructionBase
-
-    ####
-    ##  Try to parse an incbin directive
     def self.parse(line)
-      ##  Anonymous scope
+      # Anonymous scope
       match_data = line.match(/^\.scope$/)
-      unless match_data.nil?
-        return EnterScope.new
-      end
+      return EnterScope.new unless match_data.nil?
 
-      ##  Named scope
+      # Named scope
       match_data = line.match(/^\.scope\s+([a-zA-Z][a-zA-Z0-9_]+)$/)
       return nil if match_data.nil?
+
       EnterScope.new(match_data[1])
     end
 
-
-    ####
-    ##  Initialize with filename
+    # Initialize with filename
     def initialize(name = nil)
       @name = name
     end
 
-
-    ####
-    ##  Execute on the assembler, also create a symbol referring to 
-    ##  the current pc which contains a hyphen, and is impossible for
-    ##  the user to create.  This makes a scope simultaneously act as
-    ##  a label to the current PC.  If someone tries to use a scope
-    ##  name as a label, it can return the address when the scope opened.
+    # Execute on the assembler, also create a symbol referring to
+    # the current pc which contains a hyphen, and is impossible for
+    # the user to create.  This makes a scope simultaneously act as
+    # a label to the current PC.  If someone tries to use a scope
+    # name as a label, it can return the address when the scope opened.
     def exec(assembler)
       assembler.symbol_table.enter_scope(@name)
-      unless @name.nil?
-        assembler.symbol_table.define_symbol("-#{@name}", assembler.program_counter)
-      end
+      assembler.symbol_table.define_symbol("-#{@name}", assembler.program_counter) unless @name.nil?
     end
 
-
-    ####
-    ##  Display
     def to_s
       ".scope #{@name}"
     end
-
   end
-
 end