Drums are very off compared to the Z80, and the pitch still needs some work.

You can see the current progress here:

https://m.youtube.com/watch?v=W1Br7rr8cps

If you’re interested in the code (and can help eliminating bugs / inconsistencies / misinterpretations) this is what I have so far (BeebAsm format for the BBC Micro):

VIA_DDRA    = $FE43
VIA_DDRB    = $FE42
VIA_ORA     = $FE41
VIA_ORB     = $FE40
SN_LOUD     = $90
SN_MUTE     = $9F

SAMPLES_PER_FRAME = 260
SAMPLES_LO = SAMPLES_PER_FRAME AND 255
SAMPLES_HI = SAMPLES_PER_FRAME DIV 256

ORG 0

.seq_ptr        SKIP 2
.row_timer      SKIP 1
.sample_count   SKIP 2
.tmp_mix        SKIP 1
.ctrl_a         SKIP 1
.ctrl_b         SKIP 1
.pat_ptr        SKIP 2
.drum_flag      SKIP 1
.drum_index     SKIP 1
.drum_delay     SKIP 1
.drum_state     SKIP 1

.ch1_f          SKIP 2
.ch1_a          SKIP 2
.ch1_e          SKIP 2
.ch1_d          SKIP 1
.ch1_n          SKIP 1

.ch2_f          SKIP 2
.ch2_a          SKIP 2
.ch2_e          SKIP 2
.ch2_d          SKIP 1
.ch2_n          SKIP 1

.ch3_f          SKIP 2
.ch3_a          SKIP 2
.ch3_e          SKIP 2
.ch3_d          SKIP 1

.ch4_f          SKIP 2
.ch4_a          SKIP 2
.ch4_e          SKIP 2
.ch4_d          SKIP 1
.ch4_s          SKIP 1

ORG $1100
.start
    SEI
    JSR init_hw
    
    LDA #LO(music_data+2)
    STA seq_ptr
    LDA #HI(music_data+2)
    STA seq_ptr+1
    
    JSR fetch_new_pattern
    JMP check_row

.pattern_end 
    LDA seq_ptr
    CLC
    ADC #2
    STA seq_ptr
    BCC p_next
    INC seq_ptr+1
.p_next
    LDY #0
    LDA (seq_ptr),Y
    STA pat_ptr
    INY
    LDA (seq_ptr),Y
    STA pat_ptr+1
    
    LDA pat_ptr
    ORA pat_ptr+1
    BNE check_row
    
    LDA music_data
    STA seq_ptr
    LDA music_data+1
    STA seq_ptr+1
    JMP pattern_end

.check_row
    LDY #0
    LDA (pat_ptr),Y
    CMP #$40
    BEQ pattern_end

.rdseq
    LDA (pat_ptr),Y
    INY
    STA ctrl_a
    LDA (pat_ptr),Y
    INY
    STA row_timer
       
    LDA (pat_ptr),Y
    STA ch2_n
    INY
    LDA (pat_ptr),Y
    STA ch1_n
    INY

    LDA ctrl_a
    LSR A
    BCS ld2
    LDA (pat_ptr),Y
    STA ch1_f
    INY
    LDA (pat_ptr),Y
    STA ch1_f+1
    INY
    LDA (pat_ptr),Y
    STA ch1_e
    INY
    LDA (pat_ptr),Y
    STA ch1_e+1
    INY
    LDA #0
    STA ch1_a
    STA ch1_a+1
    STY tmp_mix
    LDY #0
    LDA (ch1_e),Y
    STA ch1_d
    LDY tmp_mix
.ld2
    LDA ctrl_a
    AND #4
    BNE ld3
    LDA (pat_ptr),Y
    STA ch2_f
    INY
    LDA (pat_ptr),Y
    STA ch2_f+1
    INY
    LDA (pat_ptr),Y
    STA ch2_e
    INY
    LDA (pat_ptr),Y
    STA ch2_e+1
    INY
    LDA #0
    STA ch2_a
    STA ch2_a+1
    STY tmp_mix
    LDY #0
    LDA (ch2_e),Y
    STA ch2_d
    LDY tmp_mix
.ld3
    BIT ctrl_a
    BMI ld4
    LDA (pat_ptr),Y
    STA ch3_f
    INY
    LDA (pat_ptr),Y
    STA ch3_f+1
    INY
    LDA (pat_ptr),Y
    STA ch3_e
    INY
    LDA (pat_ptr),Y
    STA ch3_e+1
    INY
    LDA #0
    STA ch3_a
    STA ch3_a+1
    STY tmp_mix
    LDY #0
    LDA (ch3_e),Y
    STA ch3_d
    LDY tmp_mix
.ld4
    LDA (pat_ptr),Y
    STA ctrl_b
    INY
    INY
    
    LDA #0
    STA drum_flag
    LDA ctrl_b
    AND #$04
    BEQ no_kick
    LDA #1
    STA drum_flag
    LDA #0
    STA drum_index
    STA drum_delay
    LDA #SN_MUTE
    STA drum_state
.no_kick
    LDA ctrl_b
    AND #$80
    BEQ no_hat
    LDA #2
    STA drum_flag
    LDA #0
    STA drum_index
    STA drum_delay
    LDA #SN_MUTE
    STA drum_state
.no_hat
    
    LDA ctrl_b
    AND #$40
    BNE skip4
    LDA (pat_ptr),Y
    STA ch4_f
    INY
    LDA (pat_ptr),Y
    STA ch4_f+1
    INY
    LDA (pat_ptr),Y
    STA ch4_e
    INY
    LDA (pat_ptr),Y
    STA ch4_e+1
    INY
    LDA #0
    STA ch4_a
    STA ch4_a+1
    STY tmp_mix
    LDY #0
    LDA (ch4_e),Y
    STA ch4_d
    LDY tmp_mix
.skip4
    LDA ctrl_b
    AND #1
    STA ch4_s

    TYA
    CLC
    ADC pat_ptr
    STA pat_ptr
    BCC p_adv
    INC pat_ptr+1
.p_adv
    LDA ch1_n
    BEQ ch1_no_noise_smc
    LDA #$6A
    STA ch1_noise_op
    LDA #$EA
    STA ch1_noise_op+1
    JMP ch2_smc
.ch1_no_noise_smc
    LDA #$EA
    STA ch1_noise_op
    STA ch1_noise_op+1
    
.ch2_smc
    LDA ch2_n
    BEQ ch2_no_noise_smc
    LDA #$6A
    STA ch2_noise_op
    LDA #$EA
    STA ch2_noise_op+1
    JMP start_synth
.ch2_no_noise_smc
    LDA #$EA
    STA ch2_noise_op
    STA ch2_noise_op+1
    
.start_synth
    LDA #SAMPLES_LO
    STA sample_count
    LDA #SAMPLES_HI
    STA sample_count+1
    CLC

.synth_loop
    LDA #0
    STA tmp_mix

    \ Channel 1
    LDA ch1_a
    ADC ch1_f
    STA ch1_a
    LDA ch1_a+1
    ADC ch1_f+1
    STA ch1_a+1
.ch1_noise_op
    NOP
    NOP
    ADC ch1_d
    ROL tmp_mix

    \ Channel 2
    LDA ch2_a
    ADC ch2_f
    STA ch2_a
    LDA ch2_a+1
    ADC ch2_f+1
    STA ch2_a+1
.ch2_noise_op
    NOP
    NOP
    ADC ch2_d
    ROL tmp_mix

    \ Channel 3
    LDA ch3_a
    ADC ch3_f
    STA ch3_a
    LDA ch3_a+1
    ADC ch3_f+1
    STA ch3_a+1
    ADC ch3_d
    ROL tmp_mix

    \ Channel 4
    LDA ch4_a
    ADC ch4_f
    STA ch4_a
    LDA ch4_a+1
    ADC ch4_f+1
    STA ch4_a+1
    ADC ch4_d
    ROL tmp_mix

    LDA tmp_mix
    ADC #$0F
    TAX

    CPX #$10
    LDA #SN_MUTE        
    BCS vol_set        
    LDA #SN_LOUD       
.vol_set
    TAY                

    LDX drum_flag
    BEQ output_no_drum 
    
    LDX drum_delay
    BEQ need_new_sample
    DEC drum_delay
    LDA drum_state
    JMP mix_tone_drum
    
.need_new_sample
    LDX drum_flag
    DEX
    BEQ need_load_kick
    DEX
    BEQ need_load_hat
    LDA drum_state
    JMP mix_tone_drum
    
.need_load_kick
    LDX drum_index
    CPX #20
    BCS need_kick_end
    LDA kick_data,X
    STA drum_delay
    INC drum_index
    LDA drum_state
    EOR #$0F
    STA drum_state
    JMP mix_tone_drum

.need_kick_end
    LDA #0
    STA drum_flag
    STA drum_delay
    LDA drum_state
    JMP mix_tone_drum

.need_load_hat
    LDX drum_index
    CPX #20
    BCS need_hat_end
    LDA hat_data,X
    STA drum_delay
    INC drum_index
    LDA drum_state
    EOR #$0F
    STA drum_state
    JMP mix_tone_drum

.need_hat_end
    LDA #0
    STA drum_flag
    STA drum_delay
    LDA drum_state
    JMP mix_tone_drum

.output_no_drum
    TYA                
    STA VIA_ORA
    LDA #0
    STA VIA_ORB
    LDA #8
    STA VIA_ORB
    JMP sample_decrement
    
\ Mix tone and drum
.mix_tone_drum
    STA ctrl_a         
    CPY #SN_LOUD
    BNE drum_only      
    CMP #SN_LOUD
    BNE tone_only       
    LDA #$98            
    JMP output_mixed
.drum_only
    LDA ctrl_a          
    JMP output_mixed
.tone_only
    TYA                 
.output_mixed
    STA VIA_ORA
    LDA #0
    STA VIA_ORB
    LDA #8
    STA VIA_ORB

.sample_decrement
    LDA sample_count
    BNE dec_lo
    DEC sample_count+1
.dec_lo
    DEC sample_count
    LDA sample_count
    ORA sample_count+1
    BEQ update_timer
    JMP synth_loop

.update_timer
    LDY #0
    INC ch1_e
    BNE e1
    INC ch1_e+1
.e1 
    LDA (ch1_e),Y
    CMP #$80
    BEQ e2
    STA ch1_d
.e2 
    INC ch2_e
    BNE e2_skip
    INC ch2_e+1
.e2_skip 
    LDA (ch2_e),Y
    CMP #$80
    BEQ e3
    STA ch2_d
.e3 
    INC ch3_e
    BNE e3_skip
    INC ch3_e+1
.e3_skip 
    LDA (ch3_e),Y
    CMP #$80
    BEQ e4
    STA ch3_d
.e4 
    INC ch4_e
    BNE e4_skip
    INC ch4_e+1
.e4_skip 
    LDA (ch4_e),Y
    CMP #$80
    BEQ slide_proc
    STA ch4_d

.slide_proc
    LDA ch4_s
    BEQ noslide
    LDA ch4_f+1
    LSR A
    TAX
    LDA ch4_f
    ROR A
    TAY
    SEC
    LDA ch4_f
    STY tmp_mix
    SBC tmp_mix
    STA ch4_f
    LDA ch4_f+1
    STX tmp_mix
    SBC tmp_mix
    STA ch4_f+1
.noslide
    DEC row_timer
    BNE play_same_row
    JMP check_row

.play_same_row
    LDA #SAMPLES_LO
    STA sample_count
    LDA #SAMPLES_HI
    STA sample_count+1
    CLC
    JMP synth_loop

.fetch_new_pattern
    LDY #0
    LDA (seq_ptr),Y
    STA pat_ptr
    INY
    LDA (seq_ptr),Y
    STA pat_ptr+1
    
    LDA pat_ptr
    ORA pat_ptr+1
    BNE fetch_done
    
    LDA music_data
    STA seq_ptr
    LDA music_data+1
    STA seq_ptr+1
    JMP fetch_new_pattern
.fetch_done
    RTS

.kick_data
    EQUB 1,1,1,1,2,2,2,2
    EQUB 3,3,3,4,4,4,5,5
    EQUB 6,6,7,7

.hat_data
    EQUB 16,3,12,6,9
    EQUB 20,4,8,2,14
    EQUB 9,17,5,8,12
    EQUB 4,7,16,13,22
    EQUB 5,3,16,3,12

.init_hw
    LDA #$9F
    JSR sn_w
    LDA #$BF
    JSR sn_w
    LDA #$DF
    JSR sn_w
    LDA #$FF
    JSR sn_w
    LDA #$FF
    STA VIA_DDRA
    LDA #$0F
    STA VIA_DDRB
    LDA #$81
    JSR sn_w
    LDA #$00
    JSR sn_w
    RTS
.sn_w
    STA VIA_ORA
    LDX #0
    STX VIA_ORB
    LDX #8
    STX VIA_ORB
    RTS

ORG $2000
    INCLUDE "tracks\Squeeker Plus\1-bit_high_and_rising.asm"
.end
SAVE "MAIN",start,end

BaWaMI seems to be the only software on Windows 64-Bit that can actually manage to use the IBM PC Speaker. This on its own is a huge achievement considering Microsoft tried to kill off IBM PC Speaker support in 64-Bit Windows. However it has some glaring issues. For Example: The "PERC" channel does not play like a normal percussion instrument as seen in other IBM PC Speaker Games instead it makes the IBM PC Speaker play Percussive Samples that seems to be the Pulse Code Modulation method. Causing the other channels to not play at all and causing the program itself to Lock Up or to Freeze despite the Intel Core i5-6500 having more than enough power to handle the Digitized "PERC" Channel

After some digging i found this in BaWaMI's credits: - Logix4U & Highresolution Enterprises's InpOut32 and ported InpOutx64
  are used for direct PC speaker control.

https://www.youtube.com/watch?v=iqWJeM2MKt4
http://cowlark.com/ptracker/

https://www.youtube.com/watch?v=XSCKzUER7VY

https://habr.com/ru/companies/timeweb/articles/835798/

The article is in Russian only, and I can't get Google Translate to pick it up by some reason, but many example sounds are there.

https://github.com/bushy555/TRS80-model … AL_SPEAKER

As a quick example: SquatM\Lets Go : https://youtu.be/a37N2d97Xck

Assemble to a .CMD file, which has an eight byte header - of which I'm still to find the specifics on.
Using a special TRS80 'Z80asm.exe' assembler, it spits out the binary directly to a .CMD file with this specific header.  I'll eventually find the info and chuck it into the source for Pasmo and SJASM.
Biggest drama with this z80asm.exe assembler is that is doesn't accept hex as $THIS or #THAT. Everything has to be THISh.

Details:

ORG $6000
Cassette port hangs off Bits 0 and 1 on port 255.
Output: Bits 0-1: 00=0.85 Volts, 10=0.0 Volts, 01 = 0.46 Volts
So... spit out values $00 and $02 to OUT ($FF)

Lyndon89 engine (I think), "mental" tune was the simplest and so far the best sounding; didn't even need to touch anything with the speed. Jut worked. And this is with the model 1 running at , what 1.8 Mhz or so.
I'll continue to play with this for the next few weeks to see how many engines and tunes I can get running ok.

The Sam Coupe was one of these lesser known Z80 based computers, being released in 1989 and discontinued in 1992.
https://en.wikipedia.org/wiki/SAM_Coup%C3%A9

Its AY port is 511 & 255, whilst its beeper port is identical to the ZX Speccy: bit 4 on port #FE.
Asm orgin for the Coupe is at #8000

Loading the binary is the difficult part when you don't know how to.
Requires to load the binary into a disk image, then load the disk image into an emulator , or using another tool to write the disk image to a real Coupe 800kb floppy drive.

Timing is right off, as this computer runs the Z80 at 6meg. Slowing things down to a reasonable listenable tempo, still makes all tunes sound like that they have been put through a Phaser. Twice.

At the BASIC prompt , either in an emulator (Sim Coupe) or, real hardware with disk image access:

LOAD "file" CODE 32768

Have converted a bunch of various players over and experimented with speed / tempo. But none are really worthwhile in showing here.  Indeed the Sam Coupe will play them all as a cool proof-of-concept, but requires far more expert-level work to making them sound nice.

I probably won't contiue fiddling with this computer, as I know that its far beyond my knowledge to get the tunes sounding nice - time to move on to another, slower, 8 bitter.

At a guess most other engines should also work using the very minor changes.

origin    $6500
bit 4 port $0084   

        device zxspectrum128
    org $6500-13                ; Origin
tap_b:    db $22,"NONAME",$22    ;name             
    db "M"                    ;type             
    dw end-begin                ;program length         
    dw begin                        ;load point       
    org $6500
begin:
...
OUT ($84), A
...
end

tap_e:    savebin "letsgo.tap",tap_b,tap_e-tap_b

You can hear this playing back a BBC Micro emulator here: https://twitter.com/charge_negative/sta … 7711753485

I'm wondering if there are options to optimize this file automatically, as compiled with player is over 27kb (out of 32kb available)?

I'm also interested in whether any of the other engines have been ported to the 6502 (or variants) with source code available?  My Z80 knowledge to do this myself isn't up to the task.

Finally, a long shot but does anyone have ideas on how to convert SN76489 LFSR noise to SquatM noise/percussion? (fixed rather than tuned).

Thanks,

Negative Charge

> Jupiter ACE I/O Ports
>
>Port FEh Read (or any Read with A0=0)
>  0-4  Keyboard Bits
>  5    Cassette Input (EAR/LOAD)
>  6-7  Not used
>Any read from this port toggles the speaker "off". Speaker IN.
>
>
>Port FEh Write (or any Write with A0=0)
>  0-2  Not used
>  3    Cassette Output (MIC/SAVE)
>  4-7  Not used
>Any write to this port toggles the speaker "on".  Speaker OUT.

So, something like:
   out     (0),a        Speaker Out
   in         a,(0)        Speaker In

So far everything has been a fail for me, but, I enjoy the fiddling around & experimenting.
One of these days I'll crack it and get something (anything) to work.

Eventually I came up with the thought: why not design a platform like these the way I'd like to see it - I totally capable to do it. Hence this idea was born, to make a virtual platform that is strictly 1-bit in the media output (visuals, sound), much like Arduboy, but that is prone to the hardware compatibility issues, like CHIP8, and can be both interesting OR easy to program. I plan to design it as an emulator (virtual machine), then make my own custom hardware implementation (MCU based, emulation driven as well). All open source, of course.

I would call this thing 1-BOY and steal the 1-bit forum header design for its own logo. I'm totally sure not many outside our community will get interested with it, but whatever. We deserved to have our own 1-bit platform, after all.

The basics are:

128x64 1-bit display, can be LCD, OLED or TFT in the hardware implementation (unified frame buffer access only, no direct control)
1-bit stereo sound
8 buttons (D-Pad, A/B, L/R shoulders)
Z80 core at some higher-than-normal frequency
64K of RAM
Programmable interrupts
Some extras

Yep, much like ZX Spectrum or TI calcs, but in a portable console shape and DIY. It could be programmed directly in Z80 assembly, as we like it, or in C using SDCC and a custom library to handle sprites etc. It does not consider huge games, because no one is going to make those for such a basic device anyways (but an overlay loading is considered in the extras).

Now the interesting question is the sound system. I can see plenty of ways how to design it in a most interesting way to explore it later - we basically can have anything we couldn't with the real hardware. However, unlike the hardware that could go insane bit flip frequencies, it will be always affected by the sample rate, and considering the hardware version of it is going to run at a less than stellar cheap MCU at first (something like 160-240 MIPS), it won't be too high.

Possible ideas I've had. I'm not sure which one to stick to:

1) A register with 8 output bits, each acting as a beeper. Two additional registers to control each of the bits, to direct it to the left, right, center, or mute. Like, %BBBBBBBB (8 beeper output), %LLLLLLLL and %RRRRRRRR (routing to L/R outputs). This way we could have 8 channels without the need to mix them, they're summed at the output. That's the old PDP-1 inspired way that had 4 mono channels in the early 1-bit music experiments.

2) Just two output bits, L/R, but with an optional reset counters that will drop it back to 0 after a given number of ticks since writing an 1. Basically a hardware narrow pulse technique. That is, you write 200 in the Lcounter, write 1 to the L channel, and it stays 1 for 200 CPU t-states.

3) Alternative implementation to 2, instead of traditional output bits just write a value to a counter, and it'll set output level for the given amount of time. 255 to keep 1 indefinitely, 0 to force output reset.

4) A buffered beeper. L/R bits, but you can feed them with new bits at any rate, and they'll get played back at a fixed rate. That's probably the most robust system for an emulator-based implementation, as we can set that fixed rate to, say, 44100, matching the actual sample rate, and we can also have a modified Z80 core with all t-states reduced to 1. However, I can't get my head around it yet, how difficult it would be in the actual use.

5) Any other ideas that would move sound generation away from Z80 core. I believe this is less interesting approach, as it leaves not much to explore and exploit. Something like a 3-8 chained PITs, much like PC speaker, but multichannel and with ability to set pulse duration.

A programmable timer, like, NMI or IRQ, can be also set to the emulation output sample rate (that may be configurable), so the software sound synth could be interrupt-driven, given the virtual Z80 have enough time to run it that frequent. But it works more towards Squeeker and Phaser like engines, kinda leaving out the pin pulse ones (depends on the sample rate).

Unlike other similar pc speaker youtube playlists. My playlist only contains videos made by myself. As of writing this there are 225 videos on the playlist both are long form & short form. So yeah there is a lot to listen to in this playlist. I use DBGL & Dosbox & OBS Studio to make these videos and i use GIMP to make the custom thumbnails

I don't know if i should say this next part. But if you liked listening to my content then please consider to subscribe to my channel i would really appreciate it. Because the youtube algorithm doesn't really want to target the correct audience to listen to my videos. Keep in mind though that i also make other kinds of videos aside from 1-Bit Music.