sonraki »

[i_r_on]

@Skate : Akşam denerim. Gözle baktığımda çalışır gözüküyor.

Bir optimizasyon ipucu : 7. Bit 1 set edilerek gönderilen senkronizasyon byte'ına da veri koyabilirsiniz.

[eins]

Ben proof of concept çalışmasını yaptım. Öngöremediğim bir exception oluştu ama çözdüm, aşağıda anlatacağım...

Peş peşe gelen encode edilmiş iki byte aynı olduğu zaman 0 basıyordum ya, burada sorun yok. Ancak bu işlemden sonra gelen byte da tesadüfen 0 olur ise, arka arkaya iki 0 basılmış oluyor. Benim her yeni gelen byte mutlaka bir öncekinden farklı olacak teorimi (self clocking data aslında bu) bozuyor... Ender olsa da karşılaştım bu durmla.

Çözüm olarak, placeholder olarak sadece 0 değil, hem 0 hem de 1 byte'ını kullandım. Placeholder koymak istediğimde, eğer bir önce bastığım byte 0 ise, bu sefer 1 basıyorum. Tabi bu durumda hem 0 hem de 1 değeri kullanılamaz oluyor. Yani 2/256 gibi bir fire mevcut. Bir de peş peşe gelen byte olasılığından dolayı bir overhead var, ortalamada istatistiksel olarak beklentim 3/256 byte şeklinde...

Bunu denemek için bir command line packer/unpacker yazdım. Gerçekte bu yazılıma ihtiyaç yok, encode işini uC yapacak decode işini C64...

Denemek için kullanımı:
Encode için > xorpck64 infile.prg
Decode için > xorpck64 -d infile.xor

Encode edince aynı isimli xor uzantılı bir dosya oluşturuyor. Bu dosyada arka arkaya gelen hiç bir byte aynı değil. (Bunu program ayrıca kontrol ediyor ve Sequence Check Passed yada Fail şeklinde bildiriyor.)

Decode edince de xor dosyasından bir prg dosyası üretiyor. Ama uzantı olarak prx kullandım ki, orjinal dosya bozulmasın, encode/decode sağlıklı yapılmış mı kontrol edebilelim...

Encoder Kodu: (Not bu pascal kodu ama mantığı anlaşılsın diye post ediyorum zaten.)

Kod:

    while not eof(f) do
    begin
      // Read a byte ...
      read(f,dta);

      repeat
        // Encode Byte ...
        res:=dta xor ctr;
        inc(ctr);

        // If the result is same with previous result,
        // or if the result is a placeholder, Encode not completed. Push a placeholder and re-encode the byte...
        done:=(res<>pdta) and (res<>0) and (res<>1);

        if not done then
        begin
          // Generate a non-repeating placeholder ...
          if pdta=0 then res:=1 else res:=0;
        end;

        // Push the byte ...
        if res=pdta then SeqCheck:=false;
        write(g,res);
        pdta:=res;

      until done;
    end;

Decoder Kodu:
Decode tabiki daha basit olacak şekilde optimize edildi. Zira asm ile C64 içinde koşacak bu kısım.

Kod:

    while not eof(f) do
    begin
      repeat
        // Fetch a byte And Decode it.
        read(f,dta);
        res:=dta xor ctr;
        inc(ctr);

        // Discard if a placeholder ...
        done:=(dta<>0) and (dta<>1);
      until done;
      write(g,res);
    end;

Bir kaç gerçek dosya ile deneme yaptım. Sonuçlar tabiki dosyaya göre değişiyor ancak ortalamada 1.9% gibi bir overhead gözlemledim. Eğer 7/8bit şeklinde bir encoding yapıyor olsa idik, %12.5 gibi bir overhead olacaktı ki, c64 tarafında 7/8bit decoding için yazacağımız code ve cycle da cabası. Bu yöntem byte based çalıştığı için bence çok daha efektif.

İlk uygun zamanımda c64 tarafını yazacağım...

EDIT: Tek dezavantajı, streaming işlerde byte/sn aktarım hızı sabit olmadığı için bazı projelere limon sıkıyor. Bir şekilde ayrıca buffer underrun, overrun kontrolü yapılarak çözülebilir.

[eins]

Asm kodum da aşağıdaki gibi.

Kod:

	lda #$00
	sta $ff
	tax
	tay
	
asynctransfer
			
-	cpy cartport		; 4cyc/3byte Wait for a change on port
	beq -			; 3cyc/2byte 
	inc $ff			; 5cyc/2byte increment xor counter
	
	lda cartport		; 4cyc/3byte fetch new value ...
	beq asynctransfer	; 3cyc/2byte if 0 discard byte
	cmp #$01			; 2cyc/2byte if 1 discard byte
	beq asynctransfer	; 3cyc/2byte 
	
	tay			; 2cyc/1byte

	eor $ff			; 3cyc/2byte Decode using xor counter 
	sta tapebuffer,x	; 5cyc/3byte Store to destination
	inx					; 2cyc/1byte Increment destination pointer
	bne asynctransfer	; 3cyc/2byte

Teorik olarak loop uzunluğu maks 37 cycle.
uC'nin delay kısmını es geçersek, max transfer hızı 27000Byte/sn gibi.
Encodingden gelen ortalama %2 overhead'i de ilave edince 22000Byte/sn hız ile yükleme mümkün...

Toplam kod 30byte civarı. Kod içerisindeki $ff herhangi bir zero page değişken.

Kesin daha kısası yazılabilir, hatta başlangıça destination adres ve uzunluk gönderilerek 256 byte üzeri yüklemeler de yapılabilir.

EDIT: Bu arada ilk cpy kontrolünden sonra, port değişince, lda ile port bir daha okunuyor. Aslında bu noktada optimizasyon için tya kullanılabilirdi ve aşağılardaki tay ye de gerek kalmazdı. Ama örnek koddadki ataomik olamama durumu yüzünden bu şekilde bıraktım.

[eins]

Bir nebze daha optimize olanı. Tek kontrol ile 0 yada 1 mi karar veriliyor.
#11111110 ile andleyince 0 çıkıyorsa, ya 1 dir ya da 0 ... İkisi de placeholder.

Kod:

	lda #$00
	sta $ff
	tax
	tay
	
asynctransfer
			
-	cpy cartport		; 4cyc/3byte Wait for a change on port
	beq -				; 3cyc/2byte 
	inc $ff				; 5cyc/2byte increment xor counter
	ldy cartport		; 4cyc For atomic problem ...

	tya					; 2cyc
	and #254			; 2cyc
	beq asynctransfer	; 3cyc/2byte if 0 or 1 discard byte
	
	tya					; 2cyc
	eor $ff				; 3cyc/2byte Decode using xor counter 
	sta tapebuffer,x	; 5cyc/3byte Store to destination
	inx					; 2cyc/1byte Increment destination pointer
	bne asynctransfer	; 3cyc/2byte

[wizofwor]

Hız olarak delimawi'nin metoduna yaklaşabileceğini zannetmiyorum ama beklemesiz kodum aşağıda:

Çalışma mantığı verinin ilk önce 7. biti değiştirerek, ikinci defasında doğru değeri vererek iki kez gönderilmesine dayanıyor.

İlk gönderilen veri kontrol değeri oluyor. Program bu değer değişene kadar beklemede kalıyor.

Kod:

transfer: { 
// başlamak için porttaki değerin değişmesini bekle
read:							
	lda port 				
	bmi wait_pl 
wait_mi:
	lda port 
	bpl wait_mi
	jmp write		
wait_pl:
	lda port
	bmi wait_pl

// değeri kopyala					 
write:						
	sta tAddr:#startAddr	

// adresi arttır 			
	inc tAddr 				
	bne read 	 			
		inc tAddr+1 		
		lda >endAddr+1 		
		cmp tAddr+1 		
		bne read 			

// hedef addresi sıfırla 
reset: 						
	lda #>startAddr 		
	sta tAddr 				
	lda #<startAddr 		
	sta tAddr+1
	rts
}
transferEnd:

[eins]

@wizofwor, benim çözümüm efektif gibi görünse bile cycle bazında bakmak lazım. Yanlış saymadıysam benim kod 37cycle/byte. x1.2 overhead, totalde 44.5cycle/byte düşünülebilir...

Yani aslında her byte'ı senin çözümde olduğu gibi iki kere gönderip, %100 overhead'i göze alıp cycle bazında kısmak daha efektif sonuç verebilir. Senin çözümdeki byte/cycle oranı nedir, nehsapladın mı?

[eins]

Meselea aşağıdaki kod çok saçma gibi görünüyor, ilk aldığı veriyi doğrudan çöpe atıp ikinci aldığını yazıyor.

Kod:

-	lda cartport		; 4cyc/3byte Wait for a change on port
	beq -				; 3cyc/2byte 
-	lda cartport		; 4cyc/3byte Wait for a change on port
	beq -				; 3cyc/2byte 
	
	sta tapebuffer,x	; 5cyc/3byte Store to destination
	inx					; 2cyc/1byte Increment destination pointer
	bne asynctransfer	; 3cyc/2byte

Ama çok efektif, çünkü loop 24cycle/byte.
Gönderen yazılımın da her iki byttab birinin çöpe gittiğini bilerek, arka arkaya aynı byte gelmeyecek şekilde aralara random veri serpiştirmesi yeterli..

EDIT: Bu arada kodu yanlış yamışım, arada cmp cartport lar olacak unutulmuş...

[Skate]

Bu haliyle 32 cycle dersek memory'nin izin verdiği kadar unroll ederek 28.75 cycle ortalamaya düşürebiliriz.

Kod:

	ldx #$00
asynctransfer
!for i, 4 {
	lda cartport		; 4 cyc
-	cmp cartport		; 4 cyc
	beq -			; 3 cyc
	lda cartport		; 4 cyc
-	cmp cartport		; 4 cyc
	beq -			; 3 cyc
	sta tapebuffer+(i-1),x	; 5 cyc
}
	txa			; 2 cyc
	sbx #-4			; 2 cyc
	bne asynctransfer	; 3 cyc

Bu kod parçası 82 byte kaplıyor, geri kalan kod için 45 byte yer kalıyor. Tabii ki daha çok yer ihtiyacı olursa unroll edilen kısım 4'den daha az tekrara düşürülebilir.

Edit: Index kısmında ufak bir mantık hatası var. Az sonra düzelteceğim.

Edit 2: Düzelttim.

[Skate]

Artık bunu yeni mesaj olarak yazayım. 20 kere editledim mesajı, özür. Son hali budur.

[i_r_on]

Gerçi çoğunluk uymadı ama F7 blok transfer etme gereksinimini kaldırıyorum.

256 byte transferi benim de test etmem kolay.

Çözümlerinizin çalışıp çalışmadığını test etmek için düzeneği hazırlıyorum. Aslında kafamda esp'nin wireless özelliğini kullanıp programları web'den yükleme fikri de vardı ancak şimdilik kolay ama amele olan firmware'in içine gömme yoluna gideceğim.

Bu arada hangi assembler'ı kullandığınızı da yazarsanız süper olur.

[Skate]

Ben compile etmeden teorik olarak yazdım ancak kullandığım format ACME'nin formatı. Şu anda KickAssembler kullanıyorum aslında ama 10 yılı aşkın bir süre ACME kullanmış olduğum için hızlıca yazarken o formata dönüşüyor kod bir anda.

Eğer ACME kullanacak olursanız aklınızda olsun, illegallerin çalışması için kodun başına;

Kod:

!cpu 6510

eklemeniz gerekir.

Kodun loop açılmış düz syntax'ı da şu şekilde

Kod:

	ldx #$00
asynctransfer
	lda cartport		; 4 cyc
-	cmp cartport		; 4 cyc
	beq -			; 3 cyc
	lda cartport		; 4 cyc
-	cmp cartport		; 4 cyc
	beq -			; 3 cyc
	sta tapebuffer,x	; 5 cyc

	lda cartport		; 4 cyc
-	cmp cartport		; 4 cyc
	beq -			; 3 cyc
	lda cartport		; 4 cyc
-	cmp cartport		; 4 cyc
	beq -			; 3 cyc
	sta tapebuffer+1,x	; 5 cyc

	lda cartport		; 4 cyc
-	cmp cartport		; 4 cyc
	beq -			; 3 cyc
	lda cartport		; 4 cyc
-	cmp cartport		; 4 cyc
	beq -			; 3 cyc
	sta tapebuffer+2,x	; 5 cyc

	lda cartport		; 4 cyc
-	cmp cartport		; 4 cyc
	beq -			; 3 cyc
	lda cartport		; 4 cyc
-	cmp cartport		; 4 cyc
	beq -			; 3 cyc
	sta tapebuffer+3,x	; 5 cyc

	txa			; 2 cyc
	sbx #$fc		; 2 cyc
	bne asynctransfer	; 3 cyc

Kullandığınız editör "sbx" desteklemiyorsa "axs" de deneyebilirsiniz, bazen böyle geçiyor. Her ikisini de desteklemiyorsa "sbx #$fc" yerine;

Kod:

!byte $cb, $fc

ya da

Kod:

.byte $cb, $fc

deneyebilirsiniz. Birinden biri tutacaktır.

[eins]

@skate, ben şöyle bir çözüm buldum, ne diyorsun?
NOT: Kod teorik, denenmedi...

Çözüm 8'lik bytelar halinde çalışıyor, hedef hiçbir şekilde arka arkaya glen iki byte'ın aynı olmaması. Bunu sağlamak için de encoder, 0. biti override edip devamlı olarak 0,1,0,1 ... şeklinde değiştiriyor. Yani 0. bit decoder tarafından kullanılamıyor. Amacı sadece synch pulse.

8 byte gönderildikten sonra bu 8 byte'ın gerçek LSB degerlerini iceren bir ekstra byte daha gönderiliyor.

Kod:

	lda #0			; 2cyc
	ldx #32			; 2cyc
	
loop:

; (8 kere tekrarla) = 16cyc * 8 = 128cyc 	

-	cmp cartport	; 4cyc Port değişimini bekle ...
	bne -			; 3cyc
	lda cartport	; 4cyc Port degisti, degeri al,
	sta buffer+n,x	; 5cyc yerine koy
	
; Simdi bu 8 byte'ın LSB bitleri bir byte olarak gelecek .... 13+8*9+2+5 = Toplam 92cyc 
	
-	cmp cartport		; 4cyc Port değişimini bekle ...
	bne -				; 3cyc
	lda cartport		; 4cyc Port degisti, A içerisinde önceki 8 byte'ın LSB degerleri var.
	tay					; 2cyc Bunu şimdilik saklayalım çünkü port değişimi kontrolünde ihtiyacımız var ...

	rol a				; 2cyc 7.biti Carry'e al
	ror buffer+0,x		; 7cyc İlgili adrese yerleştir ...
	rol a				; 2cyc 6.biti al 
	ror buffer+32,x		; 7cyc 
	rol a				; 2cyc
	ror buffer+64,x		; 7cyc
	rol a				; 2cyc
	ror buffer+96,x		; 7cyc
	rol a				; 2cyc
	ror buffer+128,x	; 7cyc
	rol a				; 2cyc
	ror buffer+160,x	; 7cyc
	rol a				; 2cyc
	ror buffer+196,x	; 7cyc
	rol a				; 2cyc
	ror buffer+228,x	; 7cyc
	
	tya				; 2cyc
	
	dex				; 2cyc
	bne loop		; 3cyc 

Yanlış hesaplaması isem 27.5cyc/byte

[eins]

Hatta bu versiyonu da 27.375cyc/byte

Kod:

	lda #0			; 2cyc
	ldx #32			; 2cyc
	
loop:

; 14cyc

-	cmp cartport	; 4cyc Port değişimini bekle ...
	bne -			; 3cyc
	lda cartport	; 4cyc Port degerini al, bu sonraki 8 byte'ın gerçek MSB degeri olacak ...
	sta $FF 		; 3cyc Zero page'de dursun ...
	
; (8 kere tekrarla) = 25cyc * 8 = 200cyc 	

-	cmp cartport	; 4cyc Port değişimini bekle ...
	bne -			; 3cyc

	lda cartport	; 4cyc Port degisti, degeri al,
	rol $FF			; 5cyc Zero page'de duran MSB bit degiskeninin 7.bitini caarry'e al.
	ror a			; 2cyc Carry deki deger A'ya kaydır ...
	sta buffer+n,x	; 5cyc yerine koy
	rol a			; 2cyc A'yı eski haline cevir ...
	
; loop control 5cyc
	
	dex				; 2cyc
	bne loop		; 3cyc 

[i_r_on]

Test mekanizmasını kurmak epey uğraştırdı.

Şu an sadece ilk paylaştığım basit rutini ve Skate'in ilk paylaştığını test edebildim.

Öncelikle, ikisi de çalışıyor.

Skate'in ilk paylaştığı için mikro tarafındaki kod şöyle

Kod:

void CartInterface::InitCustomTransfer()  {
  /* Cart software waits for data while page is negative */
  SetPage(0x80);    
  delayMicroseconds(d1);  
  /* Enable cartridge so on restart rom code is executed */    
}

void CartInterface::TransmitCustomByteAsync(uint8_t value)  {    
  /* Send the upper 7 bits as [0XXXXXXX], a positive value */
  SetPage((value >> 1) & 0x7F);
  
  /* Delay a bit to keep the pace */
  delayMicroseconds(d2);
  
  /* Cart software waits for data while page is negative
     with 8th bit value as [X000000X] */  
  SetPage(0x80 | (value & 0x01));  
  /* Delay a bit to keep the pace */
  delayMicroseconds(d3);    
}

d1=0, d2=15, d3=3 tatlı noktası. d0 fasaryadan gerçi de, d2 ve d3 daha fazla azaltılamıyor.

mikronun portu set etmesi vesairesi ile beraber 256 byte için 8232 mikrosaniye sürdü. (sadece ana loop içinde geçirilen süreyi hesaplıyorum)

Test ettiğim kod şuydu.

Kod:

;------------------------------------------------ TEST BED	
; load stub
	ldx #$00
	
asynctransfer
-	lda cartport			;4 
	bmi -					;3
	sta buffer,x			;5
-	lda cartport			;4
	bpl -					;3
	lsr						;2
	rol buffer,x			;7
	
	inx						;2
	bne asynctransfer		;3

;------------------------------------------------ TEST BED	

Test için 256 byte demo a mind is born'u kullanmak mantıklı mı oldu bilemedim

Kurduğum mekanizmadan bahsedeyim.

Soruyu sorarken kod rom'dan çalışsın derken büyük hata etmişim. Zira ben bu test'leri yaparken rom'dan çalıştırmaya kalksaydım eprom yaz, dene, tekrar yaz sürecine girecektim. ESP8266 ile kartuşu ilk çalıştırırken elimdeki shift register'ların arızalı olmasından dolayı hali hazırda yaşadım bunu. Aslında kodda hiç değişiklik gerektirmeyen bu arıza yüzünden NMI olmadan transfer denemeleri yaptım. Onu geçtim yine aslında çalışan kodu sırf ekranı tekrar açmayı unuttuğum için çalışmıyor zannedip diye de bir sürü uğraştım. Her zaman yazdığım loop koduna mel mel ne sorunu olabilir acaba diye baktım anlayacağınız

Kartuşta şöyle bir mekanizma var, rom üstünde ilk yüklenecek programın adresi, uzunluğu vesaire transfer olurken ardından rom'daki kodun uzantısı olacak bir rutinin yüklemesi yapılıyor. Bu rutin kaset buffer'ına yükleniyor. Sonra da esas yüklenecek programın yüklemesi yapılıp bu rutine dallanılıyor.

Sizin transfer rutinleri için her seferinde eprom yazmayayım, kaset buffer'a yüklediğim rutin sizin transfer rutinleri olsun. Yüklenecek ana program da dummy 256 byte'lık bir şey olsun.

Sizin rutinlerinizin yükleyip çalıştıracağı da bir programa ihtiyaç var. 256 byte transfer edilmesinden sebep aklıma 256 byte bir demo çalıştırmak makul gözüktü.

Özetle şöyle oluyor.

1. Kartuş aktif hale getiriliyor, C64 resetleniyor
2. Eprom'daki stock rutinle 256 byte'lık dummy bir data yükleniyor. Stub loader olarak sizin transfer rutini de kaset buffer'a yükleniyor. (Rutinlerinizdeki data transfer ettiğiniz adresi kaset buffer değil $0801 olacak şekilde değiştirdim)
3. Kaset buffer'daki transfer rutininiz çalıştırılıyor. Zamanlama ölçümü düzgün olsun diye ESP8266'nın ram'ine yerleştirdiğim 256 byte'lık demo programın yüklemesi yapılıyor. Kartuş disable edilip program çalıştırılıyor.


Vakit buldukça diğer rutinleri de test edip her birini ayrı bir klasörde saklayacağım. Benim yaptığım test rutinin çalışıp çalışmadığının testi aslında. En düşük çalışma zamanı hangisinin diyebilmek için cycle saymak lazım.

[Skate]

@delimawi: Senin versiyonunu inceleyecek vakit bulamamıştım. Şimdi inceledim, en süper çözüm bu olmuş. Tek sıkıntısı 8 kere tekrar eden blok tek başına 120 byte tutuyor. 128 byte'dan küçük olması kuralına uymak için loop eklersek de yavaş kalıyor. 128 byte üstü çözüm olarak en iyisi bu olmuş. Benim 128 byte üstü çözüm olarak aklıma gelen başka yöntemler de vardı (aralarında 16 bytelık 16 farklı adreste konumlandırılmış tablo içerenleri falan da vardı). Bunu 128 byte limitine sıkıştırmanın yolu bulunursa en ideal çözüm bu olacaktır.

edit: Bu arada ikinci gönderdiğinden bahsediyorum. İlkinde sanırım bir mantık hatası var. Gözle takip ettiğimde eksik kalan bir şeyler var.