CPCWiki - THE Amstrad CPC encyclopedia! - User contributions [en]

Programming:Keyboard scanning

2026-01-14T14:59:51Z

Urusergi: /* Complete keyboard scanning routine */

== Hardware scancodes ==

=== English table ===
{|{{Prettytable|width: 700px; font-size: 2em;}}
|'''Bit: Line''' || '''7''' || '''6''' || '''5''' || '''4''' || '''3''' || '''2''' || '''1''' || '''0'''
|-
|'''&40''' || F Dot || ENTER || F3 || F6 || F9 || CURDOWN || CURRIGHT || CURUP
|-
|'''&41''' || F0 || F2 || F1 || F5 || F8 || F7 || COPY || CURLEFT
|-
|'''&42''' || CONTROL || \ ` || SHIFT || F4 || ] } || RETURN || [ { || CLR
|-
|'''&43''' || . > || / ? || : * || ; + || P || @ ¦ || - = || ^ £
|-
|'''&44''' || , < || M || K || L || I || O || 9 ) || 0 _
|-
|'''&45''' || SPACE || N || J || H || Y || U || 7 ' || 8 (
|-
|'''&46''' || V || B (Joy2 fire3) || F (Joy2 fire2) || G (Joy2 fire1) || T (Joy2 right) || R (Joy2 left) || 5 % (Joy2 down)|| 6 & (Joy2 up)
|-
|'''&47''' || X || C || D || S || W || E || 3 # || 4 $
|-
|'''&48''' || Z || CAPSLOCK || A || TAB || Q || ESC || 2 " || 1 !
|-
|'''&49''' || DEL || Joy1 fire3 || Joy1 fire2 ||Joy1 fire1||Joy1 right||Joy1 left||Joy1 down||Joy1 up
|}

=== Danish table ===
{|{{Prettytable|width: 700px; font-size: 2em;}}
|'''Bit: Line''' || '''7''' || '''6''' || '''5''' || '''4''' || '''3''' || '''2''' || '''1''' || '''0'''
|-
|'''&40''' || F Dot || ENTER || F3 || F6 || F9 || CURDOWN || CURRIGHT || CURUP
|-
|'''&41''' || F0 || F2 || F1 || F5 || F8 || F7 || COPY || CURLEFT
|-
|'''&42''' || CONTROL || ; + || SHIFT || F4 || : * || RETURN || @ \ || CLR
|-
|'''&43''' || . > || / ? || Æ || Ø || P || Å || - = || ^ £
|-
|'''&44''' || , < || M || K || L || I || O || 9 ) || 0 _
|-
|'''&45''' || SPACE || N || J || H || Y || U || 7 ' || 8 (
|-
|'''&46''' || V || B (Joy2 fire3) || F (Joy2 fire2) || G (Joy2 fire1) || T (Joy2 right) || R (Joy2 left) || 5 % (Joy2 down)|| 6 & (Joy2 up)
|-
|'''&47''' || X || C || D || S || W || E || 3 # || 4 $
|-
|'''&48''' || Z || CAPSLOCK || A || TAB || Q || ESC || 2 " || 1 !
|-
|'''&49''' || DEL || Joy1 fire3 || Joy1 fire2 ||Joy1 fire1||Joy1 right||Joy1 left||Joy1 down||Joy1 up
|}

=== Spanish table ===
{|{{Prettytable|width: 700px; font-size: 2em;}}
|'''Bit: Line''' || '''7''' || '''6''' || '''5''' || '''4''' || '''3''' || '''2''' || '''1''' || '''0'''
|-
|'''&40''' || F Dot || INTRO || F3 || F6 || F9 || CURDOWN || CURRIGHT || CURUP
|-
|'''&41''' || F0 || F2 || F1 || F5 || F8 || F7 || COPIA || CURLEFT
|-
|'''&42''' || CONTROL || \ ` || MAYS || F4 || ] + || RETURN || [ * || CLR
|-
|'''&43''' || . > || / ? || Ñ || ; : || P || @ ¦ || - = || ^ ₧
|-
|'''&44''' || , < || M || K || L || I || O || 9 ) || 0 _
|-
|'''&45''' || SPACE || N || J || H || Y || U || 7 ' || 8 (
|-
|'''&46''' || V || B (Joy2 fire3) || F (Joy2 fire2) || G (Joy2 fire1) || T (Joy2 right) || R (Joy2 left) || 5 % (Joy2 down)|| 6 & (Joy2 up)
|-
|'''&47''' || X || C || D || S || W || E || 3 # || 4 $
|-
|'''&48''' || Z || FIJA MAYS || A || TAB || Q || ESC || 2 " || 1 !
|-
|'''&49''' || BORR || Joy1 fire3 || Joy1 fire2 ||Joy1 fire1||Joy1 right||Joy1 left||Joy1 down||Joy1 up
|}

=== French table ===
{|{{Prettytable|width: 700px; font-size: 2em;}}
|'''Bit: Line''' || '''7''' || '''6''' || '''5''' || '''4''' || '''3''' || '''2''' || '''1''' || '''0'''
|-
|'''&40''' || F Dot || ENTER || F3 || F6 || F9 || CURDOWN || CURRIGHT || CURUP
|-
|'''&41''' || F0 || F2 || F1 || F5 || F8 || F7 || COPY || CURLEFT
|-
|'''&42''' || CONTROL || $ @\ || SHIFT || F4 || # > || RETURN || * < || CLR
|-
|'''&43''' || : / || = + || M || ù % || P || ^ ¦ || ) [ || - _
|-
|'''&44''' || ; . || , ? || K || L || I || O || ç 9 || à 0
|-
|'''&45''' || SPACE || N || J || H || Y || U || è 7 || ! 8
|-
|'''&46''' || V || B (Joy2 fire3) || F (Joy2 fire2) || G (Joy2 fire1) || T (Joy2 right) || R (Joy2 left) || ( 5 (Joy2 down)|| ] 6 (Joy2 up)
|-
|'''&47''' || X || C || D || S || Z || E || " 3 || ' 4
|-
|'''&48''' || W || CAPSLOCK || Q || TAB || A || ESC || é 2 || & 1
|-
|'''&49''' || DEL || Joy1 fire3 || Joy1 fire2 ||Joy1 fire1||Joy1 right||Joy1 left||Joy1 down||Joy1 up
|}

Note: Fire3 only work on Amstrad CPC, not on Amstrad Plus.

== Computing key code ==

System key codes (codes that are writted on the top of the disc drive on 664/6128 or in the CPC user manual) can be computed with the formula : (Line*8)+bit

Example : for key SHIFT , Line = 2 , bit = 5 so (2*8)+5 = 21

== Keyboard clash ==

This is the name of the phenomenon when a "ghost" or "phantom" key is generated when you press some combinations of keys.
It is caused by the design of the keyboard hardware. It has been tested and confirmed that keyboard clash doesn't occur on an English CPC664 keyboard.

For example, pressing Q,A,P will also generate :.

The ':' key is the "ghost" key.

The problem is much bigger in 2 player games.

It is possible to avoid or minimize the problem by carefully choosing the controls. The problem also occurs when using digital joysticks because these are part of the keyboard matrix.

If you visualize a rectangle in the keyboard matrix above, where 3 of the corners are 3 keys you have pressed. Then the key in the fourth corner will also be pressed this is the "ghost" key.

On Plus it is possible to avoid it mostly by having one player on analogue joystick and the other on keyboard/digital joystick.

== One line scanning routine ==

This is a routine which scans one line of the keyboard directly. It is approximately 8% faster than the firmware routine and doesn't enable interrupts.

'''Input:''' A = ''line (&40 - &49)''

'''Output:''' A = ''hardware keyboard value''

'''Destroyed:''' BC
<pre>LD A,kbdline ; from &40 to &49 with bdir/bc1=01
LD D,0
LD BC,#F782 ; PPI port A out /C out
OUT (C),C
LD BC,#F40E ; Select Ay reg 14 on ppi port A
OUT (C),C
LD BC,#F6C0 ; This value is an AY index (R14)
OUT (C),C
OUT (C),D ; Validate!! out (c),0
LD BC,#F792 ; PPI port A in/C out
OUT (C),C
DEC B
OUT (C),A ; Send KbdLine on reg 14 AY through ppi port A
LD B,#F4 ; Read ppi port A
IN A,(C) ; e.g. AY R14 (AY port A)
LD BC,#F782 ; PPI port A out / C out
OUT (C),C
DEC B ; Reset PPI Write
OUT (C),D ; out (c),0

Register A now holds the value of requested keyboard row
Now check for the value from the table e.g. with''''bit x,A''''and a condition e.g.''''jp z,xxxx''''or''''call z,xxxx''''
</pre>
Please note:

* Bit = 0: Key is pressed
* Bit = 1: Key is not pressed

== Complete keyboard scanning routine ==

This routine scans the complete keyboard and writes all key status bits in a map.

<pre>
keymap ds 10 ;map with 10*8 = 80 key status bits (bit=0 key is pressed)

keyscan di ;1 ##%%## C P C VERSION ##%%##
xor a ;1
ld hl,keymap ;3
ld bc,#f782 ;3
out (c),c ;4
ld bc,#f40e ;3
out (c),c ;4
ld e,b ;1
ld bc,#f6c0 ;3
out (c),c ;4
ld d,b ;1
out (c),a ;4
sub c ;1 a=#40 (-#C0)
ld bc,#f792 ;3
out (c),c ;4
ld c,d ;1 (+41)
loop ld b,d ;1
out (c),a ;4 select line
ld b,e ;1
ini ;5 read bits and write into KEYMAP
inc a ;1
inc c ;1
jr nz,loop ;2/3 (9*16+1*15 = 159)
ld bc,#f782 ;3
out (c),c ;4
ei ;1 (+8 = 208 microseconds)
ret
</pre>

== Developing programs that use joystick ==

In the CPC world it is more common that a game supports both keyboard and digital joystick for those users who don't own joysticks.
In addition, it is also nice if the keys could be redefined but that is not necessary.

The standard CPC can support 3 buttons per joystick, though many CPC joysticks only have 1 button.

The CPC+ and GX4000 only support 2 buttons per joystick, and the included Amstrad joypads have 2 buttons.

There are some common keyboard configurations used:

* '''Joystick''' - This configuration is compatible with all Amstrad machines, even the GX4000 and you need to scan only one keyboard line (this means you can't be faster)

* '''Cursor keys & SPACE''' - This configuration is often used and is great for the CPC6128 and Plus and playing using emulators. This is '''not''' good for CPC 464 and 664 (which have uncomfortably arranged cursor keys)

* '''Q,A,O,P,SPACE''' - (Q up, A down, O left, P right, SPACE fire) This is a good solution, and it's a sort of standard (used by many games). It is best for english QWERTY keyboards, on french AZERTY it'd be A-Q-O-P (but because the decoding of the keys is done in software, normally by the OS, the bits in the keyboard matrix are actually the same).

The standard CPC has only 1 digital joystick port (and no analog joystick port). But it was possible to daisy chain the official Amstrad joysticks. And a common accessory, the joystick port doubler, offered 2 digital joystick ports.

The CPC+ and GX4000 have 2 digital joystick ports built-in (and 1 analog joystick port).

== See Also ==

* [[Digital Joysticks]]
* [[Keyboard Versions]]

[[Category:Programming]][[Category:CPC Internal Components]]

CPCng

2025-04-17T18:46:24Z

Urusergi:

[[Image:Cpcng.jpg|thumb|CPCng case design]]

The '''CPCng''' (CPC next generation) projects aim was to build a new and very poweful Amstrad CPC compatible computer. The project was managed by [[Christophe Guelff]] from France. It should be based on an eZ80 CPU and could run in CPC compatible mode or in an extended 16bit mode.

Currently the project seems to be on hold or dead. Also with the release of the [[CPC TREX]] with its [[TobiFlex]] 24MHz TurboCPC core the question appeared, if the originally CPCng project still makes sense, or if it would be better to focus on a pure FPGA-based ready-produced industrial solutions like the CPC TREX.

Nevertheless Douglas Beatties CPCng homepage has still been updated not a long time ago, so there is still the chance, that the CPCng will be reality at some day.

== Web links ==

* [http://www.hanssummers.com/cpcng.html Hans Summers CPCng homepage]
* [http://cpcng.hytherion.com/ Douglas Beatties CPCng homepage]
* [http://fr.wikipedia.org/wiki/Color_Computer_New_Generation french Wikipedia article]
* [http://www.digi-alt.net/cpcoxygen/magazine/08/contents.htm CPCng special in CPC Oxygen #8]

[[Category:Hardware]][[Category:Vaporware]][[Category:Non CPC Computers]][[Category:Clones]]

Programming:Unlocking ASIC

2025-04-07T19:10:45Z

Urusergi: /* Urusergi version */

To unlock the [[ASIC]], a 17-byte "unlock" sequence must be sent to the [[CRTC]]'s selection port (&BC00) :
RQ00, 0, 255, 119, 179, 81, 168, 212, 98, 57, 156, 70, 43, 21, 138, STATE, <ACQ>
* RQ00 must be different from the value 0.
* STATE=205 for UNLOCK otherwise another value for LOCK.
* ACQ represents sending any value if STATE=205 (not needed otherwise).

Note: the ASIC is already unlocked after the STATE phase, before ACQ. So ACQ is actually never needed.

Once the ASIC is unlocked, we get access to a new [[Gate Array]] register called RMR2. It is accessible in the same way as other Gate Array registers.

 

= BASIC version =
<pre>
10 RESTORE
20 FOR x=0 TO 16:READ a:OUT &BC00,a:NEXT
30 DATA 255,0,255,119,179,81,168,212,98,57,156,70,43,21,138,205,238
40 PRINT"ASIC unlocked!"
</pre>

 

= Z80 Assembler version =
<pre>
;; This example shows how to unlock the ASIC
;;
;; This example is designed for CPC+ only and will
;; not work on CPC or KC Compact.
;;
;; This example will compile with the MAXAM assembler
;; or the built-in assembler of WinAPE32.

org &8000

;;--------------------------------------------------
;; Unlock CPC+ additional features

di
ld b,&bc
ld hl,sequence
ld e,17

.seq
ld a,(hl)
out (c),a
inc hl
dec e
jr nz,seq

ei
ret

;;----------------------------------------------------------
;; this is the sequence to unlock the ASIC extra features
.sequence
defb &ff,&00,&ff,&77,&b3,&51,&a8,&d4,&62,&39,&9c,&46,&2b,&15,&8a,&cd,&ee
</pre>

 

= Optimized versions =

The unlocking sequence can be reconstituted from simple bit operations instead of being stored in memory.

== [[Madram]] version ==

It still uses some magic numbers.

<pre>
di
ld bc,#BCFF
out (c),c
out (c),0
ld hl,%1001000011101010

loop:
out (c),c
ld a,h:rlca:ld h,l:ld l,a
srl c
xor c:and #88:xor c
ld c,a
cp #4D
jr nz,loop

ld a,#CD ; a = #CD for unlock, another value for lock
out (c),a:out (c),a
ei
ret
</pre>

== [[Urusergi]] version ==

No magic numbers here.

<pre>
di ; v3.1 -> 30 bytes!
ld bc,#BCFF
out (c),c
out (c),0 ; db #ED,#71
ld a,c

loop:
out (c),a
ld h,a ; h = 7654 3210
add hl,hl ; h = 6543 210*
rra ; a = 7765 4321
add hl,hl ; h = 5432 10**
xor h:and #F7:xor h ; a = 7765 1321
ld l,a ; l = 7765 1321
ld a,h ; a = 5432 10**
rla ; a = 4321 0***
and #88:xor l ; a = (7 xor 4)765 (1 xor 0)321
cp c
jr nz,loop

ei
ret
</pre>

== Algorithm ==

<pre>
def unlock_asic():
b, c = 0xBC, 0xFF
out(b, c)
out(b, 0)
a = c

while True:
out(b, a)
# a = (7 xor 4)765 (1 xor 0)321
a = ((a >> 1) & 0x77) | ((a ^ (a << 3)) & 0x80) | (((a << 2) ^ (a << 3)) & 0x08)
if a == c: break

def out(port, value):
print(f"Port: {hex(port)}xx Out: {hex(value)}")

unlock_asic()
</pre>

 

= Visual representation =

As one may see, the nybbles in the sequence are based on two 4bit shift registers.

[[File:AsicUnlockSequence.png]]

Visual by [[Hwikaa]]

 

= Patent =
For one reason or another, Amstrad has patented the verification mechanism ([[Media:Patent GB2243701A.pdf|GB2243701A]]).

The patent seems to focus on ''verifying'' (rather than on ''sending'') the sequence, so its legal use is a bit unclear.

On the [[Original Arnold V Specs]] - Issue 1.5 - 10th April 1990, it is precised at §2.11 "Locking of enhanced features":
<code>
it should be noted that unauthorised use of this mechanism may infringe Amstrad's patent.
</code>

According to [https://patents.google.com/patent/GB2243701A/en Google patents for GB2243701A] the patent was withdrawn on 1994-12-21. This means that this particular patent cannot be enforced.
 

[[Category:Programming]]
[[Category:CPC Plus]]

Programming:Unlocking ASIC

2025-04-07T14:38:20Z

Urusergi: /* Urusergi version */

To unlock the [[ASIC]], a 17-byte "unlock" sequence must be sent to the [[CRTC]]'s selection port (&BC00) :
RQ00, 0, 255, 119, 179, 81, 168, 212, 98, 57, 156, 70, 43, 21, 138, STATE, <ACQ>
* RQ00 must be different from the value 0.
* STATE=205 for UNLOCK otherwise another value for LOCK.
* ACQ represents sending any value if STATE=205 (not needed otherwise).

Note: the ASIC is already unlocked after the STATE phase, before ACQ. So ACQ is actually never needed.

Once the ASIC is unlocked, we get access to a new [[Gate Array]] register called RMR2. It is accessible in the same way as other Gate Array registers.

 

= BASIC version =
<pre>
10 RESTORE
20 FOR x=0 TO 16:READ a:OUT &BC00,a:NEXT
30 DATA 255,0,255,119,179,81,168,212,98,57,156,70,43,21,138,205,238
40 PRINT"ASIC unlocked!"
</pre>

 

= Z80 Assembler version =
<pre>
;; This example shows how to unlock the ASIC
;;
;; This example is designed for CPC+ only and will
;; not work on CPC or KC Compact.
;;
;; This example will compile with the MAXAM assembler
;; or the built-in assembler of WinAPE32.

org &8000

;;--------------------------------------------------
;; Unlock CPC+ additional features

di
ld b,&bc
ld hl,sequence
ld e,17

.seq
ld a,(hl)
out (c),a
inc hl
dec e
jr nz,seq

ei
ret

;;----------------------------------------------------------
;; this is the sequence to unlock the ASIC extra features
.sequence
defb &ff,&00,&ff,&77,&b3,&51,&a8,&d4,&62,&39,&9c,&46,&2b,&15,&8a,&cd,&ee
</pre>

 

= Optimized versions =

The unlocking sequence can be reconstituted from simple bit operations instead of being stored in memory.

== [[Madram]] version ==

It still uses some magic numbers.

<pre>
di
ld bc,#BCFF
out (c),c
out (c),0
ld hl,%1001000011101010

loop:
out (c),c
ld a,h:rlca:ld h,l:ld l,a
srl c
xor c:and #88:xor c
ld c,a
cp #4D
jr nz,loop

ld a,#CD ; a = #CD for unlock, another value for lock
out (c),a:out (c),a
ei
ret
</pre>

== [[Urusergi]] version ==

No magic numbers here.

<pre>
di ; v3.0 -> 30 bytes!
ld bc,#BCFF
out (c),c
out (c),0 ; db #ED,#71
ld a,c

loop:
out (c),a
ld h,a ; h = 7654 3210
add hl,hl ; h = 6543 210*
rra ; a = 7765 4321
add hl,hl ; h = 5432 10**
xor h:and #F7:xor h ; a = 7765 1321
ld l,a ; l = 7765 1321
ld a,h ; a = 5432 10**
rla ; a = 4321 0***
and #88:xor l ; a = (7 xor 4)765 (1 xor 0)321
cp c
jr nz,loop

ei
ret
</pre>

== Algorithm ==

<pre>
def unlock_asic():
b, c = 0xBC, 0xFF
out(b, c)
out(b, 0)
a = c

while True:
out(b, a)
# a = (7 xor 4)765 (1 xor 0)321
a = ((a >> 1) & 0x77) | ((a ^ (a << 3)) & 0x80) | (((a << 2) ^ (a << 3)) & 0x08)
if a == c: break

def out(port, value):
print(f"Port: {hex(port)}xx Out: {hex(value)}")

unlock_asic()
</pre>

 

= Visual representation =

As one may see, the nybbles in the sequence are based on two 4bit shift registers.

[[File:AsicUnlockSequence.png]]

Visual by [[Hwikaa]]

 

= Patent =
For one reason or another, Amstrad has patented the verification mechanism ([[Media:Patent GB2243701A.pdf|GB2243701A]]).

The patent seems to focus on ''verifying'' (rather than on ''sending'') the sequence, so its legal use is a bit unclear.

On the [[Original Arnold V Specs]] - Issue 1.5 - 10th April 1990, it is precised at §2.11 "Locking of enhanced features":
<code>
it should be noted that unauthorised use of this mechanism may infringe Amstrad's patent.
</code>

 

[[Category:Programming]]
[[Category:CPC Plus]]

Programming:Unlocking ASIC

2025-04-06T13:02:42Z

Urusergi: /* Urusergi version */

To unlock the [[ASIC]], a 17-byte "unlock" sequence must be sent to the [[CRTC]]'s selection port (&BC00) :
RQ00, 0, 255, 119, 179, 81, 168, 212, 98, 57, 156, 70, 43, 21, 138, STATE, <ACQ>
* RQ00 must be different from the value 0.
* STATE=205 for UNLOCK otherwise another value for LOCK.
* ACQ represents sending any value if STATE=205 (not needed otherwise).

Note: the ASIC is already unlocked after the STATE phase, before ACQ. So ACQ is actually never needed.

Once the ASIC is unlocked, we get access to a new [[Gate Array]] register called RMR2. It is accessible in the same way as other Gate Array registers.

 

= BASIC version =
<pre>
10 RESTORE
20 FOR x=0 TO 16:READ a:OUT &BC00,a:NEXT
30 DATA 255,0,255,119,179,81,168,212,98,57,156,70,43,21,138,205,238
40 PRINT"ASIC unlocked!"
</pre>

 

= Z80 Assembler version =
<pre>
;; This example shows how to unlock the ASIC
;;
;; This example is designed for CPC+ only and will
;; not work on CPC or KC Compact.
;;
;; This example will compile with the MAXAM assembler
;; or the built-in assembler of WinAPE32.

org &8000

;;--------------------------------------------------
;; Unlock CPC+ additional features

di
ld b,&bc
ld hl,sequence
ld e,17

.seq
ld a,(hl)
out (c),a
inc hl
dec e
jr nz,seq

ei
ret

;;----------------------------------------------------------
;; this is the sequence to unlock the ASIC extra features
.sequence
defb &ff,&00,&ff,&77,&b3,&51,&a8,&d4,&62,&39,&9c,&46,&2b,&15,&8a,&cd,&ee
</pre>

 

= Optimized versions =

The unlocking sequence can be reconstituted from simple bit operations instead of being stored in memory.

== [[Madram]] version ==

It still uses some magic numbers.

<pre>
di
ld bc,#BCFF
out (c),c
out (c),0
ld hl,%1001000011101010

loop:
out (c),c
ld a,h:rlca:ld h,l:ld l,a
srl c
xor c:and #88:xor c
ld c,a
cp #4D
jr nz,loop

ld a,#CD ; a = #CD for unlock, another value for lock
out (c),a:out (c),a
ei
ret
</pre>

== [[Urusergi]] version ==

No magic numbers here.

<pre>
di ; v3.0 -> 30 bytes!
ld bc,#BCFF
out (c),c
out (c),0 ; db #ED,#71
ld a,c

loop:
out (c),a
ld h,a ; h = 7654 3210
add hl,hl ; h = 6543 210*
rra ; a = 7765 4321
add hl,hl ; h = 5432 10**
xor h:and #F7:xor h ; a = 7765 1321
add hl,hl ; h = 4321 0***
ld l,a ; l = 7765 1321
ld a,h ; a = 4321 0***
and #88:xor l ; a = (7 xor 4)765 (1 xor 0)321
cp c
jr nz,loop

ei
ret
</pre>

== Algorithm ==

<pre>
def unlock_asic():
b, c = 0xBC, 0xFF
out(b, c)
out(b, 0)
a = c

while True:
out(b, a)
# a = (7 xor 4)765 (1 xor 0)321
a = ((a >> 1) & 0x77) | ((a ^ (a << 3)) & 0x80) | (((a << 2) ^ (a << 3)) & 0x08)
if a == c: break

def out(port, value):
print(f"Port: {hex(port)}xx Out: {hex(value)}")

unlock_asic()
</pre>

 

= Visual representation =

As one may see, the nybbles in the sequence are based on two 4bit shift registers.

[[File:AsicUnlockSequence.png]]

Visual by [[Hwikaa]]

 

= Patent =
For one reason or another, Amstrad has patented the verification mechanism ([[Media:Patent GB2243701A.pdf|GB2243701A]]).

The patent seems to focus on ''verifying'' (rather than on ''sending'') the sequence, so its legal use is a bit unclear.

On the [[Original Arnold V Specs]] - Issue 1.5 - 10th April 1990, it is precised at §2.11 "Locking of enhanced features":
<code>
it should be noted that unauthorised use of this mechanism may infringe Amstrad's patent.
</code>

 

[[Category:Programming]]
[[Category:CPC Plus]]

Programming:Unlocking ASIC

2025-04-05T17:22:26Z

Urusergi: /* Urusergi version */

To unlock the [[ASIC]], a 17-byte "unlock" sequence must be sent to the [[CRTC]]'s selection port (&BC00) :
RQ00, 0, 255, 119, 179, 81, 168, 212, 98, 57, 156, 70, 43, 21, 138, STATE, <ACQ>
* RQ00 must be different from the value 0.
* STATE=205 for UNLOCK otherwise another value for LOCK.
* ACQ represents sending any value if STATE=205 (not needed otherwise).

Note: the ASIC is already unlocked after the STATE phase, before ACQ. So ACQ is actually never needed.

Once the ASIC is unlocked, we get access to a new [[Gate Array]] register called RMR2. It is accessible in the same way as other Gate Array registers.

 

= BASIC version =
<pre>
10 RESTORE
20 FOR x=0 TO 16:READ a:OUT &BC00,a:NEXT
30 DATA 255,0,255,119,179,81,168,212,98,57,156,70,43,21,138,205,238
40 PRINT"ASIC unlocked!"
</pre>

 

= Z80 Assembler version =
<pre>
;; This example shows how to unlock the ASIC
;;
;; This example is designed for CPC+ only and will
;; not work on CPC or KC Compact.
;;
;; This example will compile with the MAXAM assembler
;; or the built-in assembler of WinAPE32.

org &8000

;;--------------------------------------------------
;; Unlock CPC+ additional features

di
ld b,&bc
ld hl,sequence
ld e,17

.seq
ld a,(hl)
out (c),a
inc hl
dec e
jr nz,seq

ei
ret

;;----------------------------------------------------------
;; this is the sequence to unlock the ASIC extra features
.sequence
defb &ff,&00,&ff,&77,&b3,&51,&a8,&d4,&62,&39,&9c,&46,&2b,&15,&8a,&cd,&ee
</pre>

 

= Optimized versions =

The unlocking sequence can be reconstituted from simple bit operations instead of being stored in memory.

== [[Madram]] version ==

It still uses some magic numbers.

<pre>
di
ld bc,#BCFF
out (c),c
out (c),0
ld hl,%1001000011101010

loop:
out (c),c
ld a,h:rlca:ld h,l:ld l,a
srl c
xor c:and #88:xor c
ld c,a
cp #4D
jr nz,loop

ld a,#CD ; a = #CD for unlock, another value for lock
out (c),a:out (c),a
ei
ret
</pre>

== [[Urusergi]] version ==

No magic numbers here.

<pre>
di ; v3.0 -> 30 bytes!
ld bc,#BCFF
out (c),c
out (c),0
ld a,c

loop:
out (c),a
ld h,a ; h = 7654 3210
add hl,hl ; h = 6543 210*
rra ; a = 7765 4321
add hl,hl ; h = 5432 10**
xor h:and #F7:xor h ; a = 7765 1321
add hl,hl ; h = 4321 0***
ld l,a ; l = 7765 1321
ld a,h ; a = 4321 0***
and #88:xor l ; a = (7 xor 4)765 (1 xor 0)321
cp c
jr nz,loop

ei
ret
</pre>

== Algorithm ==

<pre>
def unlock_asic():
b, c = 0xBC, 0xFF
out(b, c)
out(b, 0)
a = c

while True:
out(b, a)
# a = (7 xor 4)765 (1 xor 0)321
a = ((a >> 1) & 0x77) | ((a ^ (a << 3)) & 0x80) | (((a << 2) ^ (a << 3)) & 0x08)
if a == c: break

def out(port, value):
print(f"Port: {hex(port)} Out: {hex(value)}")

unlock_asic()
</pre>

 

= Visual representation =

As one may see, the nybbles in the sequence are based on two 4bit shift registers.

[[File:AsicUnlockSequence.png]]

Visual by [[Hwikaa]]

 

= Patent =
For one reason or another, Amstrad has patented the verification mechanism ([[Media:Patent GB2243701A.pdf|GB2243701A]]).

The patent seems to focus on ''verifying'' (rather than on ''sending'') the sequence, so its legal use is a bit unclear.

On the [[Original Arnold V Specs]] - Issue 1.5 - 10th April 1990, it is precised at §2.11 "Locking of enhanced features":
<code>
it should be noted that unauthorised use of this mechanism may infringe Amstrad's patent.
</code>

 

[[Category:Programming]]
[[Category:CPC Plus]]

Programming:Unlocking ASIC

2025-04-05T15:28:26Z

Urusergi: /* Madram version */

To unlock the [[ASIC]], a 17-byte "unlock" sequence must be sent to the [[CRTC]]'s selection port (&BC00) :
RQ00, 0, 255, 119, 179, 81, 168, 212, 98, 57, 156, 70, 43, 21, 138, STATE, <ACQ>
* RQ00 must be different from the value 0.
* STATE=205 for UNLOCK otherwise another value for LOCK.
* ACQ represents sending any value if STATE=205 (not needed otherwise).

Note: the ASIC is already unlocked after the STATE phase, before ACQ. So ACQ is actually never needed.

Once the ASIC is unlocked, we get access to a new [[Gate Array]] register called RMR2. It is accessible in the same way as other Gate Array registers.

 

= BASIC version =
<pre>
10 RESTORE
20 FOR x=0 TO 16:READ a:OUT &BC00,a:NEXT
30 DATA 255,0,255,119,179,81,168,212,98,57,156,70,43,21,138,205,238
40 PRINT"ASIC unlocked!"
</pre>

 

= Z80 Assembler version =
<pre>
;; This example shows how to unlock the ASIC
;;
;; This example is designed for CPC+ only and will
;; not work on CPC or KC Compact.
;;
;; This example will compile with the MAXAM assembler
;; or the built-in assembler of WinAPE32.

org &8000

;;--------------------------------------------------
;; Unlock CPC+ additional features

di
ld b,&bc
ld hl,sequence
ld e,17

.seq
ld a,(hl)
out (c),a
inc hl
dec e
jr nz,seq

ei
ret

;;----------------------------------------------------------
;; this is the sequence to unlock the ASIC extra features
.sequence
defb &ff,&00,&ff,&77,&b3,&51,&a8,&d4,&62,&39,&9c,&46,&2b,&15,&8a,&cd,&ee
</pre>

 

= Optimized versions =

The unlocking sequence can be reconstituted from simple bit operations instead of being stored in memory.

== [[Madram]] version ==

It still uses some magic numbers.

<pre>
di
ld bc,#BCFF
out (c),c
out (c),0
ld hl,%1001000011101010

loop:
out (c),c
ld a,h:rlca:ld h,l:ld l,a
srl c
xor c:and #88:xor c
ld c,a
cp #4D
jr nz,loop

ld a,#CD ; a = #CD for unlock, another value for lock
out (c),a:out (c),a
ei
ret
</pre>

== [[Urusergi]] version ==

No magic numbers here.

<pre>
di ; v3.0 -> 30 bytes!
ld bc,#BCFF
out (c),c
out (c),0
ld a,c

loop:
out (c),a
ld h,a ; h = 7654 3210
add hl,hl ; h = 6543 210*
rra ; a = 7765 4321
add hl,hl ; h = 5432 10**
xor h:and #F7:xor h ; a = 7765 1321
add hl,hl ; h = 4321 0***
ld l,a ; l = 7765 1321
ld a,h ; a = 4321 0***
and #88
xor l
cp c
jr nz,loop

ei
ret
</pre>

== Algorithm ==

<pre>
def unlock_asic():
b, c = 0xBC, 0xFF
out(b, c)
out(b, 0)
a = c

while True:
out(b, a)
a = ((a >> 1) & 0x77) | ((a ^ (a << 3)) & 0x80) | (((a << 2) ^ (a << 3)) & 0x08)
if a == c: break

def out(port, value):
print(f"Port: {hex(port)} Out: {hex(value)}")

unlock_asic()
</pre>

 

= Visual representation =

As one may see, the nybbles in the sequence are based on two 4bit shift registers.

[[File:AsicUnlockSequence.png]]

Visual by [[Hwikaa]]

 

= Patent =
For one reason or another, Amstrad has patented the verification mechanism ([[Media:Patent GB2243701A.pdf|GB2243701A]]).

The patent seems to focus on ''verifying'' (rather than on ''sending'') the sequence, so its legal use is a bit unclear.

On the [[Original Arnold V Specs]] - Issue 1.5 - 10th April 1990, it is precised at §2.11 "Locking of enhanced features":
<code>
it should be noted that unauthorised use of this mechanism may infringe Amstrad's patent.
</code>

 

[[Category:Programming]]
[[Category:CPC Plus]]

Programming:Unlocking ASIC

2025-04-05T15:24:31Z

Urusergi: /* Madram version */

To unlock the [[ASIC]], a 17-byte "unlock" sequence must be sent to the [[CRTC]]'s selection port (&BC00) :
RQ00, 0, 255, 119, 179, 81, 168, 212, 98, 57, 156, 70, 43, 21, 138, STATE, <ACQ>
* RQ00 must be different from the value 0.
* STATE=205 for UNLOCK otherwise another value for LOCK.
* ACQ represents sending any value if STATE=205 (not needed otherwise).

Note: the ASIC is already unlocked after the STATE phase, before ACQ. So ACQ is actually never needed.

Once the ASIC is unlocked, we get access to a new [[Gate Array]] register called RMR2. It is accessible in the same way as other Gate Array registers.

 

= BASIC version =
<pre>
10 RESTORE
20 FOR x=0 TO 16:READ a:OUT &BC00,a:NEXT
30 DATA 255,0,255,119,179,81,168,212,98,57,156,70,43,21,138,205,238
40 PRINT"ASIC unlocked!"
</pre>

 

= Z80 Assembler version =
<pre>
;; This example shows how to unlock the ASIC
;;
;; This example is designed for CPC+ only and will
;; not work on CPC or KC Compact.
;;
;; This example will compile with the MAXAM assembler
;; or the built-in assembler of WinAPE32.

org &8000

;;--------------------------------------------------
;; Unlock CPC+ additional features

di
ld b,&bc
ld hl,sequence
ld e,17

.seq
ld a,(hl)
out (c),a
inc hl
dec e
jr nz,seq

ei
ret

;;----------------------------------------------------------
;; this is the sequence to unlock the ASIC extra features
.sequence
defb &ff,&00,&ff,&77,&b3,&51,&a8,&d4,&62,&39,&9c,&46,&2b,&15,&8a,&cd,&ee
</pre>

 

= Optimized versions =

The unlocking sequence can be reconstituted from simple bit operations instead of being stored in memory.

== [[Madram]] version ==

It still uses some magic numbers.

<pre>
di
ld bc,#BCFF
out (c),c
out (c),0
ld hl,%1001000011101010

loop:
out (c),c
ld a,h:rlca:ld h,l:ld l,a
srl c
xor c:and #88:xor c
ld c,a
cp #4D
jr nz,loop

ld a,#CD ; a=#CD for unlock, another value for lock
out (c),a:out (c),a
ei
ret
</pre>

== [[Urusergi]] version ==

No magic numbers here.

<pre>
di ; v3.0 -> 30 bytes!
ld bc,#BCFF
out (c),c
out (c),0
ld a,c

loop:
out (c),a
ld h,a ; h = 7654 3210
add hl,hl ; h = 6543 210*
rra ; a = 7765 4321
add hl,hl ; h = 5432 10**
xor h:and #F7:xor h ; a = 7765 1321
add hl,hl ; h = 4321 0***
ld l,a ; l = 7765 1321
ld a,h ; a = 4321 0***
and #88
xor l
cp c
jr nz,loop

ei
ret
</pre>

== Algorithm ==

<pre>
def unlock_asic():
b, c = 0xBC, 0xFF
out(b, c)
out(b, 0)
a = c

while True:
out(b, a)
a = ((a >> 1) & 0x77) | ((a ^ (a << 3)) & 0x80) | (((a << 2) ^ (a << 3)) & 0x08)
if a == c: break

def out(port, value):
print(f"Port: {hex(port)} Out: {hex(value)}")

unlock_asic()
</pre>

 

= Visual representation =

As one may see, the nybbles in the sequence are based on two 4bit shift registers.

[[File:AsicUnlockSequence.png]]

Visual by [[Hwikaa]]

 

= Patent =
For one reason or another, Amstrad has patented the verification mechanism ([[Media:Patent GB2243701A.pdf|GB2243701A]]).

The patent seems to focus on ''verifying'' (rather than on ''sending'') the sequence, so its legal use is a bit unclear.

On the [[Original Arnold V Specs]] - Issue 1.5 - 10th April 1990, it is precised at §2.11 "Locking of enhanced features":
<code>
it should be noted that unauthorised use of this mechanism may infringe Amstrad's patent.
</code>

 

[[Category:Programming]]
[[Category:CPC Plus]]

Programming:Unlocking ASIC

2025-04-05T15:09:21Z

Urusergi: /* Urusergi version */

To unlock the [[ASIC]], a 17-byte "unlock" sequence must be sent to the [[CRTC]]'s selection port (&BC00) :
RQ00, 0, 255, 119, 179, 81, 168, 212, 98, 57, 156, 70, 43, 21, 138, STATE, <ACQ>
* RQ00 must be different from the value 0.
* STATE=205 for UNLOCK otherwise another value for LOCK.
* ACQ represents sending any value if STATE=205 (not needed otherwise).

Note: the ASIC is already unlocked after the STATE phase, before ACQ. So ACQ is actually never needed.

Once the ASIC is unlocked, we get access to a new [[Gate Array]] register called RMR2. It is accessible in the same way as other Gate Array registers.

 

= BASIC version =
<pre>
10 RESTORE
20 FOR x=0 TO 16:READ a:OUT &BC00,a:NEXT
30 DATA 255,0,255,119,179,81,168,212,98,57,156,70,43,21,138,205,238
40 PRINT"ASIC unlocked!"
</pre>

 

= Z80 Assembler version =
<pre>
;; This example shows how to unlock the ASIC
;;
;; This example is designed for CPC+ only and will
;; not work on CPC or KC Compact.
;;
;; This example will compile with the MAXAM assembler
;; or the built-in assembler of WinAPE32.

org &8000

;;--------------------------------------------------
;; Unlock CPC+ additional features

di
ld b,&bc
ld hl,sequence
ld e,17

.seq
ld a,(hl)
out (c),a
inc hl
dec e
jr nz,seq

ei
ret

;;----------------------------------------------------------
;; this is the sequence to unlock the ASIC extra features
.sequence
defb &ff,&00,&ff,&77,&b3,&51,&a8,&d4,&62,&39,&9c,&46,&2b,&15,&8a,&cd,&ee
</pre>

 

= Optimized versions =

The unlocking sequence can be reconstituted from simple bit operations instead of being stored in memory.

== [[Madram]] version ==

It still uses some magic numbers.

<pre>
UnlockAsic
di
ld bc,#BCFF
out (c),c
out (c),0
ld hl,%1001000011101010

.loop
out (c),c
ld a,h:rlca:ld h,l:ld l,a
srl c
xor c:and #88:xor c
ld c,a
cp #4D
jr nz,.loop

ld a,#CD ; a=#CD for unlock, another value for lock
out (c),a:out (c),a
ei
ret
</pre>

== [[Urusergi]] version ==

No magic numbers here.

<pre>
di ; v3.0 -> 30 bytes!
ld bc,#BCFF
out (c),c
out (c),0
ld a,c

loop:
out (c),a
ld h,a ; h = 7654 3210
add hl,hl ; h = 6543 210*
rra ; a = 7765 4321
add hl,hl ; h = 5432 10**
xor h:and #F7:xor h ; a = 7765 1321
add hl,hl ; h = 4321 0***
ld l,a ; l = 7765 1321
ld a,h ; a = 4321 0***
and #88
xor l
cp c
jr nz,loop

ei
ret
</pre>

== Algorithm ==

<pre>
def unlock_asic():
b, c = 0xBC, 0xFF
out(b, c)
out(b, 0)
a = c

while True:
out(b, a)
a = ((a >> 1) & 0x77) | ((a ^ (a << 3)) & 0x80) | (((a << 2) ^ (a << 3)) & 0x08)
if a == c: break

def out(port, value):
print(f"Port: {hex(port)} Out: {hex(value)}")

unlock_asic()
</pre>

 

= Visual representation =

As one may see, the nybbles in the sequence are based on two 4bit shift registers.

[[File:AsicUnlockSequence.png]]

Visual by [[Hwikaa]]

 

= Patent =
For one reason or another, Amstrad has patented the verification mechanism ([[Media:Patent GB2243701A.pdf|GB2243701A]]).

The patent seems to focus on ''verifying'' (rather than on ''sending'') the sequence, so its legal use is a bit unclear.

On the [[Original Arnold V Specs]] - Issue 1.5 - 10th April 1990, it is precised at §2.11 "Locking of enhanced features":
<code>
it should be noted that unauthorised use of this mechanism may infringe Amstrad's patent.
</code>

 

[[Category:Programming]]
[[Category:CPC Plus]]

Programming:Unlocking ASIC

2025-03-29T20:37:33Z

Urusergi: /* Urusergi version */

To unlock the [[ASIC]], a 17-byte "unlock" sequence must be sent to the [[CRTC]]'s selection port (&BC00) :
RQ00, 0, 255, 119, 179, 81, 168, 212, 98, 57, 156, 70, 43, 21, 138, STATE, <ACQ>
* RQ00 must be different from the value 0.
* STATE=205 for UNLOCK otherwise another value for LOCK.
* ACQ represents sending any value if STATE=205 (not needed otherwise).

Note: the ASIC is already unlocked after the STATE phase, before ACQ. So ACQ is actually never needed.

Once the ASIC is unlocked, we get access to a new [[Gate Array]] register called RMR2. It is accessible in the same way as other Gate Array registers.

 

= BASIC version =
<pre>
10 RESTORE
20 FOR x=0 TO 16:READ a:OUT &BC00,a:NEXT
30 DATA 255,0,255,119,179,81,168,212,98,57,156,70,43,21,138,205,238
40 PRINT"ASIC unlocked!"
</pre>

 

= Z80 Assembler version =
<pre>
;; This example shows how to unlock the ASIC
;;
;; This example is designed for CPC+ only and will
;; not work on CPC or KC Compact.
;;
;; This example will compile with the MAXAM assembler
;; or the built-in assembler of WinAPE32.

org &8000

;;--------------------------------------------------
;; Unlock CPC+ additional features

di
ld b,&bc
ld hl,sequence
ld e,17

.seq
ld a,(hl)
out (c),a
inc hl
dec e
jr nz,seq

ei
ret

;;----------------------------------------------------------
;; this is the sequence to unlock the ASIC extra features
.sequence
defb &ff,&00,&ff,&77,&b3,&51,&a8,&d4,&62,&39,&9c,&46,&2b,&15,&8a,&cd,&ee
</pre>

 

= Optimized versions =

The unlocking sequence can be reconstituted from simple bit operations instead of being stored in memory.

== [[Madram]] version ==

In Z80 Assembler:
<pre>
UnlockAsic
di
ld bc,#BCFF
out (c),c
out (c),0
ld hl,%1001000011101010

.loop
out (c),c
ld a,h:rlca:ld h,l:ld l,a
srl c
xor c:and #88:xor c
ld c,a
cp #4D
jr nz,.loop

ld a,#CD ; a=#CD for unlock, another value for lock
out (c),a:out (c),a
ei
ret
</pre>

In Python:
<pre>
def unlock_asic():
b, c, h, l = 0xBC, 0xFF, 0x90, 0xEA # Initialize registers
port_out(b, c)
port_out(b, 0)

while c != 0x4D:
port_out(b, c)
h, l = l, ((h << 1) | (h >> 7)) & 0xFF # Rotate h and swap h,l
c = ((c >> 1) & ~(1 << 3)) | (l & 0x88) # Modify c

port_out(b, 0xCD)
port_out(b, 0xCD)

def port_out(port, value):
print(f"Port: {hex(port)}xx Out: {hex(value)}")

unlock_asic()
</pre>

== [[Urusergi]] version ==
In Z80 Assembler:
<pre>
di ; v2.0 -> 31 bytes!
ld bc,#BCFF
out (c),c
out (c),0
ld a,c

.loop
out (c),a
ld h,a ; H = 7654 3210
rra ; A = *765 4321
add hl,hl ; H = 6543 210-
push af ; Carry flag (bit 7) preserved
add hl,hl ; H = 5432 10--
add hl,hl ; H = 4321 0---
pop af ; Carry flag (bit 7) recovered
ld l,a ; L = *765 4321
ld a,h ; A = 4321 0---
rra ; A = 7432 10--
xor h ; A = (7 xor 4)*** (1 xor 0)***
xor l:and #88:xor l ; A = (7 xor 4)765 (1 xor 0)321
cp c
jr nz,.loop

ei
ret
</pre>

In Python:
<pre>
def unlock_asic():
b, c = 0xBC, 0xFF
port_out(b, c)
port_out(b, 0)
a = c

while True:
port_out(b, a)
d = a
a = (((a << 2 | a >> 6) ^ d) & 0x7F) ^ d
d = (d >> 1 | d << 7) & 0xFF
a = ((((a << 1 | a >> 7) ^ a) ^ d) & 0x88) ^ d
if a == c: break

def port_out(port, value):
print(f"Port: {hex(port)}xx Out: {hex(value)}")

unlock_asic()
</pre>

 

= Visual representation =

As one may see, the nybbles in the sequence are based on two 4bit shift registers.

[[File:AsicUnlockSequence.png]]

Visual by [[Hwikaa]]

 

= Patent =
For one reason or another, Amstrad has patented the verification mechanism ([[Media:Patent GB2243701A.pdf|GB2243701A]]).

The patent seems to focus on ''verifying'' (rather than on ''sending'') the sequence, so its legal use is a bit unclear.

On the [[Original Arnold V Specs]] - Issue 1.5 - 10th April 1990, it is precised at §2.11 "Locking of enhanced features":
<code>
it should be noted that unauthorised use of this mechanism may infringe Amstrad's patent.
</code>

 

[[Category:Programming]]
[[Category:CPC Plus]]

Programming:Unlocking ASIC

2025-03-29T18:52:03Z

Urusergi: /* Urusergi version */

To unlock the [[ASIC]], a 17-byte "unlock" sequence must be sent to the [[CRTC]]'s selection port (&BC00) :
RQ00, 0, 255, 119, 179, 81, 168, 212, 98, 57, 156, 70, 43, 21, 138, STATE, <ACQ>
* RQ00 must be different from the value 0.
* STATE=205 for UNLOCK otherwise another value for LOCK.
* ACQ represents sending any value if STATE=205 (not needed otherwise).

Note: the ASIC is already unlocked after the STATE phase, before ACQ. So ACQ is actually never needed.

Once the ASIC is unlocked, we get access to a new [[Gate Array]] register called RMR2. It is accessible in the same way as other Gate Array registers.

 

= BASIC version =
<pre>
10 RESTORE
20 FOR x=0 TO 16:READ a:OUT &BC00,a:NEXT
30 DATA 255,0,255,119,179,81,168,212,98,57,156,70,43,21,138,205,238
40 PRINT"ASIC unlocked!"
</pre>

 

= Z80 Assembler version =
<pre>
;; This example shows how to unlock the ASIC
;;
;; This example is designed for CPC+ only and will
;; not work on CPC or KC Compact.
;;
;; This example will compile with the MAXAM assembler
;; or the built-in assembler of WinAPE32.

org &8000

;;--------------------------------------------------
;; Unlock CPC+ additional features

di
ld b,&bc
ld hl,sequence
ld e,17

.seq
ld a,(hl)
out (c),a
inc hl
dec e
jr nz,seq

ei
ret

;;----------------------------------------------------------
;; this is the sequence to unlock the ASIC extra features
.sequence
defb &ff,&00,&ff,&77,&b3,&51,&a8,&d4,&62,&39,&9c,&46,&2b,&15,&8a,&cd,&ee
</pre>

 

= Optimized versions =

The unlocking sequence can be reconstituted from simple bit operations instead of being stored in memory.

== [[Madram]] version ==

In Z80 Assembler:
<pre>
UnlockAsic
di
ld bc,#BCFF
out (c),c
out (c),0
ld hl,%1001000011101010

.loop
out (c),c
ld a,h:rlca:ld h,l:ld l,a
srl c
xor c:and #88:xor c
ld c,a
cp #4D
jr nz,.loop

ld a,#CD ; a=#CD for unlock, another value for lock
out (c),a:out (c),a
ei
ret
</pre>

In Python:
<pre>
def unlock_asic():
b, c, h, l = 0xBC, 0xFF, 0x90, 0xEA # Initialize registers
port_out(b, c)
port_out(b, 0)

while c != 0x4D:
port_out(b, c)
h, l = l, ((h << 1) | (h >> 7)) & 0xFF # Rotate h and swap h,l
c = ((c >> 1) & ~(1 << 3)) | (l & 0x88) # Modify c

port_out(b, 0xCD)
port_out(b, 0xCD)

def port_out(port, value):
print(f"Port: {hex(port)}xx Out: {hex(value)}")

unlock_asic()
</pre>

== [[Urusergi]] version ==
In Z80 Assembler:
<pre>
di ; v2.0 -> 31 bytes!
ld bc,#BCFF
out (c),c
out (c),0
ld a,c

.loop
out (c),a
ld h,a ; H = 7654 3210
add hl,hl ; H = 6543 210-
push af ; Carry flag (bit 7) preserved
add hl,hl ; H = 5432 10--
add hl,hl ; H = 4321 0---
rra ; A = 5765 4321
ld l,a ; L = 5765 4321
pop af ; Carry flag (bit 7) recovered
ld a,h ; A = 4321 0---
rra ; A = 7432 10--
xor h ; A = (7 xor 4)*** (1 xor 0)***
xor l:and #88:xor l ; A = (7 xor 4)765 (1 xor 0)321
cp c
jr nz,.loop

ei
ret
</pre>

In Python:
<pre>
def unlock_asic():
b, c = 0xBC, 0xFF
port_out(b, c)
port_out(b, 0)
a = c

while True:
port_out(b, a)
d = a
a = (((a << 2 | a >> 6) ^ d) & 0x7F) ^ d
d = (d >> 1 | d << 7) & 0xFF
a = ((((a << 1 | a >> 7) ^ a) ^ d) & 0x88) ^ d
if a == c: break

def port_out(port, value):
print(f"Port: {hex(port)}xx Out: {hex(value)}")

unlock_asic()
</pre>

 

= Visual representation =

As one may see, the nybbles in the sequence are based on two 4bit shift registers.

[[File:AsicUnlockSequence.png]]

Visual by [[Hwikaa]]

 

= Patent =
For one reason or another, Amstrad has patented the verification mechanism ([[Media:Patent GB2243701A.pdf|GB2243701A]]).

The patent seems to focus on ''verifying'' (rather than on ''sending'') the sequence, so its legal use is a bit unclear.

On the [[Original Arnold V Specs]] - Issue 1.5 - 10th April 1990, it is precised at §2.11 "Locking of enhanced features":
<code>
it should be noted that unauthorised use of this mechanism may infringe Amstrad's patent.
</code>

 

[[Category:Programming]]
[[Category:CPC Plus]]

Programming:Unlocking ASIC

2025-03-29T18:22:19Z

Urusergi: /* Urusergi version */

To unlock the [[ASIC]], a 17-byte "unlock" sequence must be sent to the [[CRTC]]'s selection port (&BC00) :
RQ00, 0, 255, 119, 179, 81, 168, 212, 98, 57, 156, 70, 43, 21, 138, STATE, <ACQ>
* RQ00 must be different from the value 0.
* STATE=205 for UNLOCK otherwise another value for LOCK.
* ACQ represents sending any value if STATE=205 (not needed otherwise).

Note: the ASIC is already unlocked after the STATE phase, before ACQ. So ACQ is actually never needed.

Once the ASIC is unlocked, we get access to a new [[Gate Array]] register called RMR2. It is accessible in the same way as other Gate Array registers.

 

= BASIC version =
<pre>
10 RESTORE
20 FOR x=0 TO 16:READ a:OUT &BC00,a:NEXT
30 DATA 255,0,255,119,179,81,168,212,98,57,156,70,43,21,138,205,238
40 PRINT"ASIC unlocked!"
</pre>

 

= Z80 Assembler version =
<pre>
;; This example shows how to unlock the ASIC
;;
;; This example is designed for CPC+ only and will
;; not work on CPC or KC Compact.
;;
;; This example will compile with the MAXAM assembler
;; or the built-in assembler of WinAPE32.

org &8000

;;--------------------------------------------------
;; Unlock CPC+ additional features

di
ld b,&bc
ld hl,sequence
ld e,17

.seq
ld a,(hl)
out (c),a
inc hl
dec e
jr nz,seq

ei
ret

;;----------------------------------------------------------
;; this is the sequence to unlock the ASIC extra features
.sequence
defb &ff,&00,&ff,&77,&b3,&51,&a8,&d4,&62,&39,&9c,&46,&2b,&15,&8a,&cd,&ee
</pre>

 

= Optimized versions =

The unlocking sequence can be reconstituted from simple bit operations instead of being stored in memory.

== [[Madram]] version ==

In Z80 Assembler:
<pre>
UnlockAsic
di
ld bc,#BCFF
out (c),c
out (c),0
ld hl,%1001000011101010

.loop
out (c),c
ld a,h:rlca:ld h,l:ld l,a
srl c
xor c:and #88:xor c
ld c,a
cp #4D
jr nz,.loop

ld a,#CD ; a=#CD for unlock, another value for lock
out (c),a:out (c),a
ei
ret
</pre>

In Python:
<pre>
def unlock_asic():
b, c, h, l = 0xBC, 0xFF, 0x90, 0xEA # Initialize registers
port_out(b, c)
port_out(b, 0)

while c != 0x4D:
port_out(b, c)
h, l = l, ((h << 1) | (h >> 7)) & 0xFF # Rotate h and swap h,l
c = ((c >> 1) & ~(1 << 3)) | (l & 0x88) # Modify c

port_out(b, 0xCD)
port_out(b, 0xCD)

def port_out(port, value):
print(f"Port: {hex(port)}xx Out: {hex(value)}")

unlock_asic()
</pre>

== [[Urusergi]] version ==
In Z80 Assembler:
<pre>
di ; v2.0 -> 31 bytes!
ld bc,#BCFF
out (c),c
out (c),0
ld a,c

.loop
out(c),a
ld h,a ; H = 7654 3210
add hl,hl ; H = 6543 210-
push af ; Carry flag (bit 7) preserved
add hl,hl ; H = 5432 10--
add hl,hl ; H = 4321 0---
rra ; A = 5765 4321
ld l,a ; L = 5765 4321
pop af ; Carry flag (bit 7) recovered
ld a,h ; A = 4321 0---
rra ; A = 7432 10--
xor h ; A = (7 xor 4)*** (1 xor 0)***
xor l:and #88:xor l ; A = (7 xor 4)765 (1 xor 0)321
cp c
jr nz,.loop

ei
ret
</pre>

In Python:
<pre>
def unlock_asic():
b, c = 0xBC, 0xFF
port_out(b, c)
port_out(b, 0)
a = c

while True:
port_out(b, a)
d = a
a = (((a << 2 | a >> 6) ^ d) & 0x7F) ^ d
d = (d >> 1 | d << 7) & 0xFF
a = ((((a << 1 | a >> 7) ^ a) ^ d) & 0x88) ^ d
if a == c: break

def port_out(port, value):
print(f"Port: {hex(port)}xx Out: {hex(value)}")

unlock_asic()
</pre>

 

= Visual representation =

As one may see, the nybbles in the sequence are based on two 4bit shift registers.

[[File:AsicUnlockSequence.png]]

Visual by [[Hwikaa]]

 

= Patent =
For one reason or another, Amstrad has patented the verification mechanism ([[Media:Patent GB2243701A.pdf|GB2243701A]]).

The patent seems to focus on ''verifying'' (rather than on ''sending'') the sequence, so its legal use is a bit unclear.

On the [[Original Arnold V Specs]] - Issue 1.5 - 10th April 1990, it is precised at §2.11 "Locking of enhanced features":
<code>
it should be noted that unauthorised use of this mechanism may infringe Amstrad's patent.
</code>

 

[[Category:Programming]]
[[Category:CPC Plus]]

Programming:Unlocking ASIC

2025-03-18T15:22:04Z

Urusergi:

To unlock the [[ASIC]], a 17-byte "unlock" sequence must be sent to the [[CRTC]]'s selection port (&BC00) :
RQ00, 0, 255, 119, 179, 81, 168, 212, 98, 57, 156, 70, 43, 21, 138, STATE, <ACQ>
* RQ00 must be different from the value 0.
* STATE=205 for UNLOCK otherwise another value for LOCK.
* ACQ represents sending any value if STATE=205 (not needed otherwise).

Note: the ASIC is already unlocked after the STATE phase, before ACQ. So ACQ is actually never needed.

Once the ASIC is unlocked, we get access to a new [[Gate Array]] register called RMR2. It is accessible in the same way as other Gate Array registers.

 

= BASIC version =
<pre>
10 RESTORE
20 FOR x=0 TO 16:READ a:OUT &BC00,a:NEXT
30 DATA 255,0,255,119,179,81,168,212,98,57,156,70,43,21,138,205,238
40 PRINT"ASIC unlocked!"
</pre>

 

= Z80 Assembler version =
<pre>
;; This example shows how to unlock the ASIC
;;
;; This example is designed for CPC+ only and will
;; not work on CPC or KC Compact.
;;
;; This example will compile with the MAXAM assembler
;; or the built-in assembler of WinAPE32.

org &8000

;;--------------------------------------------------
;; Unlock CPC+ additional features

di
ld b,&bc
ld hl,sequence
ld e,17

.seq
ld a,(hl)
out (c),a
inc hl
dec e
jr nz,seq

ei
ret

;;----------------------------------------------------------
;; this is the sequence to unlock the ASIC extra features
.sequence
defb &ff,&00,&ff,&77,&b3,&51,&a8,&d4,&62,&39,&9c,&46,&2b,&15,&8a,&cd,&ee
</pre>

 

= Optimized version =

The unlocking sequence can be reconstituted from simple bit operations instead of being stored in memory.

== In Z80 Assembler ==

This allowed [[Madram]] to create this optimized lock-unlock routine:
<pre>
UnlockAsic
di
ld bc,#BCFF
out (c),c
out (c),0
ld hl,%1001000011101010

.loop
out (c),c
ld a,h:rlca:ld h,l:ld l,a
srl c
xor c:and #88:xor c
ld c,a
cp #4D
jr nz,.loop

ld a,#CD ; a=#CD for unlock, another value for lock
out (c),a:out (c),a
ei
ret
</pre>

Another optimized unlock routine by [[Urusergi]]:
<pre>
di
ld bc,#BCFF
out (c),c
out (c),0
ld a,c

.loop
out (c),a
ld d,a ; D = 7654 3210
rlca:rlca ; A = 5432 1076
xor d:and #7F:xor d ; A = 7432 1076
ld e,a
rlca ; A = 4321 0767
xor e ; A = 7432 1076 XOR 4321 0767
rrc d ; D = 0765 4321
xor d:and #88:xor d ; A = (7 xor 4)765 (1 xor 0)321
cp c
jr nz,.loop

ei
ret
</pre>

== In Python ==

<pre>
def unlock_asic():
b, c, h, l = 0xBC, 0xFF, 0x90, 0xEA # Initialize registers
port_out(b, c)
port_out(b, 0)

while c != 0x4D:
port_out(b, c)
h, l = l, ((h << 1) | (h >> 7)) & 0xFF # Rotate h and swap h, l
c = ((c >> 1) & ~(1 << 3)) | (l & 0x88) # Modify c

port_out(b, 0xCD)
port_out(b, 0xCD)

def port_out(port, value):
print(f"Port: {hex(port)}xx Out: {hex(value)}")

unlock_asic()
</pre>

 

= Visual representation =

As one may see, the nybbles in the sequence are based on two 4bit shift registers.

[[File:AsicUnlockSequence.png]]

Visual by [[Hwikaa]]

 

= Patent =
For one reason or another, Amstrad has patented the verification mechanism ([[Media:Patent GB2243701A.pdf|GB2243701A]]).

The patent seems to focus on ''verifying'' (rather than on ''sending'') the sequence, so its legal use is a bit unclear.

On the [[Original Arnold V Specs]] - Issue 1.5 - 10th April 1990, it is precised at §2.11 "Locking of enhanced features":
<code>
it should be noted that unauthorised use of this mechanism may infringe Amstrad's patent.
</code>

 

[[Category:Programming]]
[[Category:CPC Plus]]

Programming:Unlocking ASIC

2025-03-18T14:51:32Z

Urusergi: /* In Z80 Assembler */

To unlock the [[ASIC]], a 17-byte "unlock" sequence must be sent to the [[CRTC]]'s selection port (&BC00) :
RQ00, 0, 255, 119, 179, 81, 168, 212, 98, 57, 156, 70, 43, 21, 138, STATE, <ACQ>
* RQ00 must be different from the value 0.
* STATE=205 for UNLOCK otherwise another value for LOCK.
* ACQ represents sending any value if STATE=205 (not needed otherwise).

Note: the ASIC is already unlocked after the STATE phase, before ACQ. So ACQ is actually never needed.

Once the ASIC is unlocked, we get access to a new [[Gate Array]] register called RMR2. It is accessible in the same way as other Gate Array registers.

 

= BASIC version =
<pre>
10 RESTORE
20 FOR x=0 TO 16:READ a:OUT &BC00,a:NEXT
30 DATA 255,0,255,119,179,81,168,212,98,57,156,70,43,21,138,205,238
40 PRINT"ASIC unlocked!"
</pre>

 

= Z80 Assembler version =
<pre>
;; This example shows how to unlock the ASIC
;;
;; This example is designed for CPC+ only and will
;; not work on CPC or KC Compact.
;;
;; This example will compile with the MAXAM assembler
;; or the built-in assembler of WinAPE32.

org &8000

;;--------------------------------------------------
;; Unlock CPC+ additional features

di
ld b,&bc
ld hl,sequence
ld e,17
.seq
ld a,(hl)
out (c),a
inc hl
dec e
jr nz,seq
ei
ret

;;----------------------------------------------------------
;; this is the sequence to unlock the ASIC extra features
.sequence
defb &ff,&00,&ff,&77,&b3,&51,&a8,&d4,&62,&39,&9c,&46,&2b,&15,&8a,&cd,&ee
</pre>

 

= Optimized version =

The unlocking sequence can be reconstituted from simple bit operations instead of being stored in memory.

== In Z80 Assembler ==

This allowed [[Madram]] to create this optimized unlock routine:
<pre>
UnlockAsic
di
ld bc,#BCFF
out (c),c
out (c),0
ld hl,%1001000011101010
.loop
out (c),c
ld a,h:rlca:ld h,l:ld l,a
srl c
xor c:and #88:xor c
ld c,a
cp #4D
jr nz,.loop
ld a,#CD ; a=#CD for unlock, another value for lock
out (c),a : out (c),a
ei
ret
</pre>

== In Python ==

<pre>
def unlock_asic():
b, c, h, l = 0xBC, 0xFF, 0x90, 0xEA # Initialize registers
port_out(b, c)
port_out(b, 0)

while c != 0x4D:
port_out(b, c)
h, l = l, ((h << 1) | (h >> 7)) & 0xFF # Rotate h and swap h, l
c = ((c >> 1) & ~(1 << 3)) | (l & 0x88) # Modify c

port_out(b, 0xCD)
port_out(b, 0xCD)

def port_out(port, value):
print(f"Port: {hex(port)}xx Out: {hex(value)}")

unlock_asic()
</pre>

 

= Visual representation =

As one may see, the nybbles in the sequence are based on two 4bit shift registers.

[[File:AsicUnlockSequence.png]]

Visual by [[Hwikaa]]

 

= Patent =
For one reason or another, Amstrad has patented the verification mechanism ([[Media:Patent GB2243701A.pdf|GB2243701A]]).

The patent seems to focus on ''verifying'' (rather than on ''sending'') the sequence, so its legal use is a bit unclear.

On the [[Original Arnold V Specs]] - Issue 1.5 - 10th April 1990, it is precised at §2.11 "Locking of enhanced features":
<code>
it should be noted that unauthorised use of this mechanism may infringe Amstrad's patent.
</code>

 

[[Category:Programming]]
[[Category:CPC Plus]]

Programming:Keyboard scanning

2024-03-28T15:55:20Z

Urusergi: /* Complete keyboard scanning routine */

== Hardware scancode table ==
{|{{Prettytable|width: 700px; font-size: 2em;}}
|'''Bit: Line''' || '''7''' || '''6''' || '''5''' || '''4''' || '''3''' || '''2''' || '''1''' || '''0'''
|-
|'''&40''' || F Dot || ENTER || F3 || F6 || F9 || CURDOWN || CURRIGHT || CURUP
|-
|'''&41''' || F0 || F2 || F1 || F5 || F8 || F7 || COPY || CURLEFT
|-
|'''&42''' || CONTROL || \ || SHIFT || F4 || ] || RETURN || [ || CLR
|-
|'''&43''' || . || / || : || ; || P || @ || - || ^
|-
|'''&44''' || , || M || K || L || I || O || 9 || 0
|-
|'''&45''' || SPACE || N || J || H || Y || U || 7 || 8
|-
|'''&46''' || V || B || F || G (Joy2 fire) || T (Joy2 right) || R (Joy2 left) || 5 (Joy2 down)|| 6 (Joy 2 up)
|-
|'''&47''' || X || C || D || S || W || E || 3 || 4
|-
|'''&48''' || Z || CAPSLOCK || A || TAB || Q || ESC || 2 || 1
|-
|'''&49''' || DEL || Joy 1 Fire 3 (CPC only) || Joy 1 Fire 2 ||Joy1 Fire 1||Joy1 right||Joy1 left||Joy1 down||Joy1 up
|}

== Computing key code ==

System key codes (codes that are writted on the top of the disc drive on 664/6128 or in the CPC user manual) can be computed with the formula : (Line*8)+bit

Example : for key SHIFT , Line = 2 , bit = 5 so (2*8)+5 = 21

== Keyboard clash ==

This is the name of the phenomenon when a "ghost" or "phantom" key is generated when you press some combinations of keys.
It is caused by the design of the keyboard hardware. It has been tested and confirmed that keyboard clash doesn't occur on an English CPC664 keyboard.

For example, pressing Q,A,P will also generate :.

The ':' key is the "ghost" key.

The problem is much bigger in 2 player games.

It is possible to avoid or minimize the problem by carefully choosing the controls. The problem also occurs when using digital joysticks because these are part of the keyboard matrix.

If you visualize a rectangle in the keyboard matrix above, where 3 of the corners are 3 keys you have pressed. Then the key in the fourth corner will also be pressed this is the "ghost" key.

On Plus it is possible to avoid it mostly by having one player on analogue joystick and the other on keyboard/digital joystick.

== One line scanning routine ==

This is a routine which scans one line of the keyboard directly. It is approximately 8% faster than the firmware routine and doesn't enable interrupts.

'''Input:''' A = ''line (&40 - &49)''

'''Output:''' A = ''hardware keyboard value''

'''Destroyed:''' BC
<pre>LD A,kbdline ; from &40 to &49 with bdir/bc1=01
LD D,0
LD BC,#F782 ; PPI port A out /C out
OUT (C),C
LD BC,#F40E ; Select Ay reg 14 on ppi port A
OUT (C),C
LD BC,#F6C0 ; This value is an AY index (R14)
OUT (C),C
OUT (C),D ; Validate!! out (c),0
LD BC,#F792 ; PPI port A in/C out
OUT (C),C
DEC B
OUT (C),A ; Send KbdLine on reg 14 AY through ppi port A
LD B,#F4 ; Read ppi port A
IN A,(C) ; e.g. AY R14 (AY port A)
LD BC,#F782 ; PPI port A out / C out
OUT (C),C
DEC B ; Reset PPI Write
OUT (C),D ; out (c),0

Register A now holds the value of requested keyboard row
Now check for the value from the table e.g. with''''bit x,A''''and a condition e.g.''''jp z,xxxx''''or''''call z,xxxx''''
</pre>
Please note:

* Bit = 0: Key is pressed
* Bit = 1: Key is not pressed

== Complete keyboard scanning routine ==

This routine scans the complete keyboard and writes all key status bits in a map.

<pre>
keymap ds 10 ;map with 10*8 = 80 key status bits (bit=0 key is pressed)

keyscan di ;1 ##%%## C P C VERSION ##%%##
ld hl,keymap ;3
ld bc,#f782 ;3
out (c),c ;4
ld bc,#f40e ;3
ld e,b ;1
out (c),c ;4
ld bc,#f6c0 ;3
ld d,b ;1
out (c),c ;4
xor a ;1
out (c),a ;4
ld bc,#f792 ;3
out (c),c ;4
ld a,#40 ;2
ld c,d ;1 (+42)
loop ld b,d ;1
out (c),a ;4 select line
ld b,e ;1
ini ;5 read bits and write into KEYMAP
inc a ;1
inc c ;1
jr nz,loop ;2/3 (9*16+1*15 = 159)
ld bc,#f782 ;3
out (c),c ;4
ei ;1 (+8 = 209 microseconds)
ret
</pre>

== Developing programs that use joystick ==

In the CPC world it is more common that a game supports both keyboard and digital joystick for those users who don't own joysticks.
In addition, it is also nice if the keys could be redefined but that is not necessary.

There are some common keyboard configurations used:

* '''Joystick''' - This configuration is compatible with all Amstrad machines, even the GX4000 and you need to scan only one keyboard line (this means you can't be faster)

* '''Cursor keys & SPACE''' - This configuration is often used and is great for the CPC6128 and Plus and playing using emulators. This is '''not''' good for CPC 464 and 664 (which have uncomfortably arranged cursor keys)

* '''Q,A,O,P,SPACE''' - (Q up, A down, O left, P right, SPACE fire) This is a good solution, and it's a sort of standard (used by many games). It is best for english QWERTY keyboards, on french AZERTY it'd be A-Q-O-P (but because the decoding of the keys is done in software, normally by the OS, the bits in the keyboard matrix are actually the same).

[[Category:Programming]][[Category:CPC Internal Components]]

Programming:Keyboard scanning

2020-06-15T20:39:20Z

Urusergi: Complete keyboard scanning routine slightly optimized

== Hardware scancode table ==
{|{{Prettytable|width: 700px; font-size: 2em;}}
|'''Bit: Line''' || '''7''' || '''6''' || '''5''' || '''4''' || '''3''' || '''2''' || '''1''' || '''0'''
|-
|'''&40''' || F Dot || ENTER || F3 || F6 || F9 || CURDOWN || CURRIGHT || CURUP
|-
|'''&41''' || F0 || F2 || F1 || F5 || F8 || F7 || COPY || CURLEFT
|-
|'''&42''' || CONTROL || \ || SHIFT || F4 || ] || RETURN || [ || CLR
|-
|'''&43''' || . || / || : || ; || P || @ || - || ^
|-
|'''&44''' || , || M || K || L || I || O || 9 || 0
|-
|'''&45''' || SPACE || N || J || H || Y || U || 7 || 8
|-
|'''&46''' || V || B || F || G (Joy2 fire) || T (Joy2 right) || R (Joy2 left) || 5 (Joy2 down)|| 6 (Joy 2 up)
|-
|'''&47''' || X || C || D || S || W || E || 3 || 4
|-
|'''&48''' || Z || CAPSLOCK || A || TAB || Q || ESC || 2 || 1
|-
|'''&49''' || DEL || Joy 1 Fire 3 (CPC only) || Joy 1 Fire 2 ||Joy1 Fire 1||Joy1 right||Joy1 left||Joy1 down||Joy1 up
|}

== Computing key code ==

System key codes (codes that are writted on the top of the disc drive on 664/6128 or in the CPC user manual) can be computed with the formula : (Line*8)+bit

Example : for key SHIFT , Line = 2 , bit = 5 so (2*8)+5 = 21

== Keyboard clash ==

This is the name of the phenomenon when a "ghost" or "phantom" key is generated when you press some combinations of keys.
It is caused by the design of the keyboard hardware. It has been tested and confirmed that keyboard clash doesn't occur on an English CPC664 keyboard.

For example, pressing Q,A,P will also generate :.

The ':' key is the "ghost" key.

The problem is much bigger in 2 player games.

It is possible to avoid or minimize the problem by carefully choosing the controls. The problem also occurs when using digital joysticks because these are part of the keyboard matrix.

If you visualize a rectangle in the keyboard matrix above, where 3 of the corners are 3 keys you have pressed. Then the key in the fourth corner will also be pressed this is the "ghost" key.

On Plus it is possible to avoid it mostly by having one player on analogue joystick and the other on keyboard/digital joystick.

== One line scanning routine ==

This is a routine which scans one line of the keyboard directly. It is approximately 8% faster than the firmware routine and doesn't enable interrupts.

'''Input:''' A = ''line (&40 - &49)''

'''Output:''' A = ''hardware keyboard value''

'''Destroyed:''' BC
<pre>LD A,kbdline ; from &40 to &49 with bdir/bc1=01
LD D,0
LD BC,#F782 ; PPI port A out /C out
OUT (C),C
LD BC,#F40E ; Select Ay reg 14 on ppi port A
OUT (C),C
LD BC,#F6C0 ; This value is an AY index (R14)
OUT (C),C
OUT (C),D ; Validate!! out (c),0
LD BC,#F792 ; PPI port A in/C out
OUT (C),C
DEC B
OUT (C),A ; Send KbdLine on reg 14 AY through ppi port A
LD B,#F4 ; Read ppi port A
IN A,(C) ; e.g. AY R14 (AY port A)
LD BC,#F782 ; PPI port A out / C out
OUT (C),C
DEC B ; Reset PPI Write
OUT (C),D ; out (c),0

Register A now holds the value of requested keyboard row
Now check for the value from the table e.g. with''''bit x,A''''and a condition e.g.''''jp z,xxxx''''or''''call z,xxxx''''
</pre>
Please note:

* Bit = 0: Key is pressed
* Bit = 1: Key is not pressed

== Complete keyboard scanning routine ==

This routine scans the complete keyboard and writes all key status bits in a map.

<pre>
keymap ds 10 ;map with 10*8 = 80 key status bits (bit=0 key is pressed)

keyscan di ;1 ##%%## C P C VERSION ##%%##
ld hl,keymap ;3
ld bc,#f782 ;3
out (c),c ;4
ld bc,#f40e ;3
ld e,b ;1
out (c),c ;4
ld bc,#f6c0 ;3
ld d,b ;1
out (c),c ;4
xor a ;1
out (c),a ;4
ld bc,#f792 ;3
out (c),c ;4
ld a,#40 ;2
ld c,#4a ;2 43
loop ld b,d ;1
out (c),a ;4 select line
ld b,e ;1
ini ;5 read bits and write into KEYMAP
inc a ;1
cp c ;1
jr c,loop ;2/3 9*16+1*15=159
ld bc,#f782 ;3
out (c),c ;4
ei ;1 8 =210 microseconds
ret
</pre>

== Developing programs that use joystick ==

In the CPC world it is more common that a game supports both keyboard and digital joystick for those users who don't own joysticks.
In addition, it is also nice if the keys could be redefined but that is not necessary.

There are some common keyboard configurations used:

* '''Joystick''' - This configuration is compatible with all Amstrad machines, even the GX4000 and you need to scan only one keyboard line (this means you can't be faster)

* '''Cursor keys & SPACE''' - This configuration is often used and is great for the CPC6128 and Plus and playing using emulators. This is '''not''' good for CPC 464 and 664 (which have uncomfortably arranged cursor keys)

* '''Q,A,O,P,SPACE''' - (Q up, A down, O left, P right, SPACE fire) This is a good solution, and it's a sort of standard (used by many games). It is best for english QWERTY keyboards, on french AZERTY it'd be A-Q-O-P (but because the decoding of the keys is done in software, normally by the OS, the bits in the keyboard matrix are actually the same).

[[Category:Programming]][[Category:CPC Internal Components]]

QuickCMD

2018-04-05T21:20:38Z

Urusergi: /* Files */

== Introduction ==
[[Image:4487394.png|thumb|QuickCMD v2.0]]

QuickCMD is a new shell-like user interface for disc-based Amstrad CPC computers.

The initial goal of this software is to provide a faster way to browse disc content and launch programs. Usually, an Amstrad CPC user tends to use BASIC prompt to first display the disc content to retrieve a filename then manually launch a program. While this process is OK and functional, this can quickly become a boring task when there is a need to browse multiple discs.

Additionally to that, this program also features some interesting commands to manage disc content that are usually not accessible from BASIC prompt. This is only possible thanks to the low-level management of a disc content, that directly read and writes sectors instead of using functionalities provided by default with the firmware. Many formats are supported, including DATA, SYSTEM and PARADOS. Due to that, disc operations are faster than the ones accessible from BASIC.

Finally, QuickCMD is really respectful regarding the system. It has a very small memory footprint, and can be easily extended with already-existing RSXs (Resident System eXtension). It also features a char display routine that is faster than the standard one provided by the firmware, so commands generally performs faster than their equivalents under BASIC.

== Installation ==

This program requires;:

*'''an Amstrad CPC 6128''';: both classic and Plus models are supported. Amstrad CPC 464s with external disc drive are currently not supported.

*'''a ROM box''';: such devices are RAMCARD, ROMBOX, etc. Because QuickCMD is provided as a ROM, you need to be able to extend your CPC with custom ROMs. More information about those devices can be found here.

You can install this ROM at any place. Just make sure to not override the installed foreground ROM (BASIC ROM is default, at rom 0) or the ROM responsible of drive management (CPM ROM is default, at rom 7).

Once installed, QuickCMD will only use &6 bytes in memory for ROM persistent data. This is possible because QuickCMD is treated as a real ROM, meaning the code is executed from ROM, and not copied back to RAM at initialization time.

When launched, QuickCMD will dynamically allocate &328 bytes of data under HIMEM address, used as temporary buffer managed during run-time. As a note, it's interesting to mention it actually takes less memory to use QuickCMD than using the regular BASIC's CAT command (that internally use &800 bytes for its temporary catalog buffer under HIMEM address).

== Commands ==

When user enters QuickCMD's user interface, a command-line prompt is visible to the user. People familiar with any DOS-based systems will recognize the workflow. User has to manually type commands in order to send orders to be executed by the computer. Commands are not case-sensitive.

Commands are;:

*'''A: or B: ''': By typing A: or B:, the user can select the corresponding drive (drive A or B). All forthcoming disc operations will be using the selected drive.

*'''ABOUT ''': This gives the credits of the program. It also reports memory usage (address and length) required for QuickCMD's execution.

*'''CAT ''': This command behaves exactly like the regular CAT command does under BASIC. Its aim is for compatibility purpose, other programs such as BonnyDOS rely on this to display hard-drive content. Hidden files from catalog are not displayed. This command is not recommended to browse a disc, prefer the DIR command instead.

*'''CATART ''': This command behaves exactly like the regular CAT command does under BASIC, excepted it also reset the screen to default's startup one (blue background with yellow letters, using graphical MODE 1). This allows to display "cat arts", which represent graphical screens displayed with CAT command. Once displayed, user can press a key to return back to default QuickCMD's screen setup. This command is internally called by DIR command when a "cat art" is automatically detected.

*'''CRTC ''': This command reports the CRTC type. CRTC is the graphical chip of the Amstrad CPC. The CRTC test is based on Madram's implementation. It may not be the best implementation out there, but does the work as expected. It's useful to know installed CRTC type when dealing with demos that are dedicated to a single CRTC type.

*'''DEL ''': This command delete a file on disc. Be aware, no confirmation is asked to the user;!

*'''DELROM ''': This command is only compatible with RAMCARD and MEGAFLASH devices. It clears memory at specified ROM number.

*'''DIR ''': This command gives the list of files on disc. It shows files in the current user only. Available size in Kb is also reported. When this command requires multiple pages to display a long list of files, it will actually ask the user to press a key at each page-scroll. There is no filename sorting, files get displayed in order of apparition when parsing catalog information. The command supports Read-Only and Hidden files. It's interesting to mention that Hidden files are also treated and shown. If catalog appears to be a "cat art", then this command will be internally redirected to CATART command.

*'''DIRALL ''': This command performs like the DIR command, excepted it lists files for ALL users (from user 0 to 15). This is interesting to find files that are not under the current user. User of file is displayed as a prefix to the filename.

*'''DIRDEL ''': This command performs like the DIR command, excepted it lists deleted files. If a file has been recently deleted and that no write access on disc have been done, it's possible to retrieve original file content using the UNDEL command.

*'''DISCINFO ''': This gives information about disc format. It reports the name of the format, its capacity in Kb, the number of maximum files that can be managed, the single- or double-sided info, as also sectors and tracks identifiers. Many formats are supported, including those managed by PARADOS.

*'''HIDE ''': This command allows to hide a file from catalog. Of course, it will be still shown under QuickCMD (flagged as a Hidden file). When using CAT command, this file will be not reported (invisible) to the user. Files hidden can be shown back to catalog by using the SHOW command.

*'''INFO ''': This gives information about specified file. It reports its type (BASIC, PROTECTED BASIC, BINARY and ASCII). If the type allows it, it also reports the Load Address, the length of the file and its Execution Address.

*'''PUTROM ''': This command is only compatible with RAMCARD devices. First parameter is the ROM's filename, second parameter is the ROM number to write to. Specified file will be put onto the rom box. User will be asked to switch on/off the corresponding write DIP switch. It makes use of default implementation provided by Ram7 (the original author of the RAMCARD). It's advised to use ROMS command before using PUTROM to make sure to not overwrite a wanted and already installed ROM.

*'''REN ''': This command is used to rename a file. The first parameter is the new filename, the second parameter is the current filename to rename. Be aware;! REN command under BASIC use a reverse convention (old filename before new one). Such a reversion is used for DOS-like compatibility.

*'''READONLY ''': This command is used to set Read-Only attribute to a specified file. Files set as Read-Only can not be deleted till this attribute got removed.

*'''READWRITE ''': This command is used to set Read-Write attribute to a specified file (which is the default for a file). Files set as Read-Write can be deleted or overwritten.

*'''ROMS ''': This lists the installed ROMs on the system. On an unexpanded CPC, ROM 0 (BASIC) and ROM 7 (CPM ROM) are listed by default. This is useful to execute this command before putting a ROM on a rom box, to know which rom number should be used. The command shows, for each installed ROM, its internal name, its version and its type (foreground, background or extension).

*'''RSX ''': This command allows the execution of a RSX. First parameter is the RSX's name, other parameters are optional parameters to be sent to RSX. Optional parameters are always treated as string types. QuickCMD offers the functionality to execute a RSX as a command, so this command is used to override QuickCMD's internal commands. This is an example to make it clear;: let's say the Arnor's UTOPIA ROM has a RSX called HELP. In QuickCMD, if user types HELP, the internal QuickCMD's HELP command will be executed. User typing RSX HELP will then bypass the QuickCMD's HELP command and execute the Arnor's UTOPIA's HELP RSX.

*'''RUN ''': This command allows the execution of a file on disc. Supported file types are BASIC, PROTECTED BASIC or BINARY. It internally makes use of the BASIC's RUN command, so it's fully compliant with all existing programs. Like the RSX command, QuickCMD offers the functionality to type a filename as a command, so this command is used to override QuickCMD's internal commands. This is an example to make it clear;: let's say we have a file on disc called HELP.BAS. In QuickCMD, if user types HELP, the internal QuickCMD's HELP command will be executed. User typing RUN HELP will then bypass the QuickCMD's HELP command and execute the file HELP.BAS located on disc.

*'''SETUSER ''': This command is used to set user for a specified file. First parameter is filename, second parameter is the user.

*'''SHOW ''': This command is used to show (unhide) a file from catalog. Shown files can be hidden back from catalog by using the HIDE command.

*'''UNDEL ''': This command is used to undelete a file. This command will fail if a disc write access has been performed since the file has been deleted. Deleted files can be shown through the DIRDEL command.

*'''USER ''': This command is used to change current user. Default user is USER 0. Note that current user is also the one used in BASIC, so if you leave QuickCMD back to BASIC, then current user will remain active.

== Tips & Tricks ==

QuickCMD also offers some additional features that can make user's activity easier.

=== SHORTCUTS ===

In order to maximize user workflows, some shortcuts are provided to enhance productivity;:

*'''ENTER ''': if you press the ENTER key while the input command line is empty, then the screen will be cleared.

*'''TAB ''': this is probably one of the most interesting feature from QuickCMD. When you start typing a filename, if you press TAB key, QuickCMD will parse the catalog and try to autocomplete filename.

*'''TAB ''': if TAB key is pressed while the input command line is empty, then DIR command will be auto-typed (and executed).

*'''ESC ''': if ESC key is pressed, then the input command line's content will be cleared.

*'''ESC or CTRL+TAB ''': if ESC key or CTRL+TAB keys are pressed, then QuickCMD will exit back to BASIC.

== EXPECTED WORKFLOWS ==

The above shortcuts actually draws what should be one of the top uses of QuickCMD. It should be specifically interesting for new comers. If you find yourself a common workflow that is not listed here, feel free to report it to the author of this program;!

*'''The "fast DIR" ''': when your Amstrad CPC got started, user just has to press CTRL+TAB to enter QuickCMD. Then, TAB key is expected to execute DIR command. Once the user chose a file to execute, the first characters composing the filename can be typed and then the filename can be auto-completed using the TAB key. Finally, press ENTER key to execute file. This workflow is ultra-fast, you will get quickly used to the CTRL+TAB then TAB scheme;! Way faster than typing CAT command under BASIC then using SHIFT + arrow keys to select a filename then pressing COPY key to copy/paste filename then pressing CTRL+left arrow then pressing CTRL+ENTER to RUN" the file.

*'''BASIC is still your friend ''': QuickCMD is not a replacement for BASIC. BASIC has important features that QuickCMD does not support, and vice versa. It has been made easy to the user to quickly switch from BASIC to QuickCMD (and from QuickCMD to BASIC) by using the CTRL+TAB keys. Since QuickCMD is a ROM, you can deal with large BASIC programs or data stored in BANKs without any kind of alteration.

*'''Recommended third-party ROMs to be used with QuickCMD ''': QuickCMD is very well integrated with Arnor's ROMs. If you need a sector editor, use UTOPIA's DEDIT command. Use UTOPIA's MEDIT command for a memory editor. Use PROTEXT to edit your source files. Use MAXAM to program your assembly source-codes. By using all these powerful tools conjointly, you will be get an efficient manner to be creative with your CPC. This is a completely safe workflow, there have been many tests during QuickCMD implementation to make sure memory was not overwritten regarding various usage of HIMEM.

*'''Rediscover your library ! ''': One of the obvious strength of QuickCMD is the ability to show Hidden files on disc, as also quickly get information about a file or disc format. From a developer point of view, it's fun to be curious about how "proper" is a program, cf. is it composed by one or two files or is it composed by multiple small hidden files;? etc. Those things generally does not appear when using regular CAT command.

== History ==
===v2.3===
*Added command history
*ROMS command : Fixed a crash when listing ROMs with corrupted names
*Another critical problem (involving stability) has been fixed with direct drive parsing
*Renamed RSX to |Q (for even faster switching between BASIC and QuickCMD)
===v2.2===
*Added support for Bryce's MegaFlash
*Renamed RO and RW commands to READONLY and READWRITE
*Removed CRTC command
*Reset screen to QuickCMD’s default if external RSX changed video mode
*DELROM now clears a rom with &FF value (was using &00)
*Fixed: was overwriting first byte after HIMEM
*Fixed: not assuming anymore than Amsdos area is always at &A700
===v2.1===
*Correctly handles missing disc in drive for all commands
*PUTROM command now checks for BINARY file-type/correct size and displays information about the file to be put on RAMCARD
*DELROM command added to clear a ROM location
*DIR (and derivatives) now correctly reports file sizes for double-sided formats (Parados 80, etc) - thank you Richard!
*RSX command now accepts integer values (decimal and hexadecimal)
*RSX command now accepts quote " " for string-typed values (this allows to get space characters in strings by example)
*Internal code refactoring for smaller memory footprint
===v2.0===
This version is a complete rewrite of version 1.0 . While the initial version was featuring the interesting concepts featured back in version 2.0, it also pointed out some negative points;:

*'''too big for what it does ''': most of the program was written in C language. While being more productive that way, the program actually took too much memory.
*'''a ROM that isn't a ROM ''': the program was stored in a ROM. When executed, the content of the ROM was actually copied into RAM to make use of dynamic memory (it's impossible to write into a ROM). That was pretty bad, as the program was launched from BANK &C7 as also some parts of memory from fixed &8000 location.
*'''poor implementation ''': the program performed poorly. Most of disc operations were based on CAS CATALOG (the CAT command), that is slow and requires a 2Kb memory buffer.
*'''custom charset ''': the program made use of a custom integrated charset. Char output routine was efficient but took lots of memory space.
*'''and more... ''': many little details that were also polluting the code base.

Instead of maintaining a program with lots of lacks, decision has been took to completely rewrite the program with a different approach. Here are the most interesting points;:

*'''asm including C ''': instead of writing a C program with some assembly code inside, it has been more efficient to write the whole application using assembly code and implementing some high-level parts in C programming language. One of the best example for such a usage is the sector parsing part, that use a C's struct to iterate through the file entries.
*'''a ROM that is a ROM ''': writing a real ROM forced to use dynamic memory management. While this technic was interesting to implement, the most interesting part to point out is that QuickCMD's memory management got actually optimized to the maximum. The list of dynamic variables has to be kept as small as possible.
*'''and more... ''': many little details that, when written a second time, get suddenly clearer and much more maintainable.

== Credits ==

Program written by '''Arnaud Storq''' (www.norecess.net, 2011)
With the help of '''Kevin Thacker''' and '''Richard Wilson''',
CRTC type detection by '''Madram''',
RAMCARD management based on implementation from '''Ram7'''.

Many thanks to every person that reported me issues with version 1... This definitively helped a lot making a better implementation for version 2;!

==Files==
[[File:Quickcmd-v23.zip|QuickCMD v2.3, local mirror]]

[[File:Quickcmd-v22.zip|QuickCMD v2.2, local mirror]]

[[File:Quickcmd-v21.zip|QuickCMD v2.1, local mirror]]

[[File:Quickcmd-v21.pdf|QuickCMD Instruction Manual, local mirror]]

[[File:Quickcmd-v20.zip|QuickCMD v2.0, local mirror]]

[[File:Quickcmd-v10.zip|QuickCMD v1.0, local mirror]]

==External Links==
[http://norecess.cpcscene.net/quickcmd.html NoRecess' QuickCMD page]

[[Category:Expansion_ROM]]

File:Quickcmd-v10.zip

2018-04-05T21:19:28Z

Urusergi:

File:Quickcmd-v22.zip

2018-04-05T21:19:09Z

Urusergi:

File:Quickcmd-v23.zip

2018-04-05T21:17:28Z

Urusergi:

QuickCMD

2018-04-05T20:46:41Z

Urusergi:

== Introduction ==
[[Image:4487394.png|thumb|QuickCMD v2.0]]

QuickCMD is a new shell-like user interface for disc-based Amstrad CPC computers.

The initial goal of this software is to provide a faster way to browse disc content and launch programs. Usually, an Amstrad CPC user tends to use BASIC prompt to first display the disc content to retrieve a filename then manually launch a program. While this process is OK and functional, this can quickly become a boring task when there is a need to browse multiple discs.

Additionally to that, this program also features some interesting commands to manage disc content that are usually not accessible from BASIC prompt. This is only possible thanks to the low-level management of a disc content, that directly read and writes sectors instead of using functionalities provided by default with the firmware. Many formats are supported, including DATA, SYSTEM and PARADOS. Due to that, disc operations are faster than the ones accessible from BASIC.

Finally, QuickCMD is really respectful regarding the system. It has a very small memory footprint, and can be easily extended with already-existing RSXs (Resident System eXtension). It also features a char display routine that is faster than the standard one provided by the firmware, so commands generally performs faster than their equivalents under BASIC.

== Installation ==

This program requires;:

*'''an Amstrad CPC 6128''';: both classic and Plus models are supported. Amstrad CPC 464s with external disc drive are currently not supported.

*'''a ROM box''';: such devices are RAMCARD, ROMBOX, etc. Because QuickCMD is provided as a ROM, you need to be able to extend your CPC with custom ROMs. More information about those devices can be found here.

You can install this ROM at any place. Just make sure to not override the installed foreground ROM (BASIC ROM is default, at rom 0) or the ROM responsible of drive management (CPM ROM is default, at rom 7).

Once installed, QuickCMD will only use &6 bytes in memory for ROM persistent data. This is possible because QuickCMD is treated as a real ROM, meaning the code is executed from ROM, and not copied back to RAM at initialization time.

When launched, QuickCMD will dynamically allocate &328 bytes of data under HIMEM address, used as temporary buffer managed during run-time. As a note, it's interesting to mention it actually takes less memory to use QuickCMD than using the regular BASIC's CAT command (that internally use &800 bytes for its temporary catalog buffer under HIMEM address).

== Commands ==

When user enters QuickCMD's user interface, a command-line prompt is visible to the user. People familiar with any DOS-based systems will recognize the workflow. User has to manually type commands in order to send orders to be executed by the computer. Commands are not case-sensitive.

Commands are;:

*'''A: or B: ''': By typing A: or B:, the user can select the corresponding drive (drive A or B). All forthcoming disc operations will be using the selected drive.

*'''ABOUT ''': This gives the credits of the program. It also reports memory usage (address and length) required for QuickCMD's execution.

*'''CAT ''': This command behaves exactly like the regular CAT command does under BASIC. Its aim is for compatibility purpose, other programs such as BonnyDOS rely on this to display hard-drive content. Hidden files from catalog are not displayed. This command is not recommended to browse a disc, prefer the DIR command instead.

*'''CATART ''': This command behaves exactly like the regular CAT command does under BASIC, excepted it also reset the screen to default's startup one (blue background with yellow letters, using graphical MODE 1). This allows to display "cat arts", which represent graphical screens displayed with CAT command. Once displayed, user can press a key to return back to default QuickCMD's screen setup. This command is internally called by DIR command when a "cat art" is automatically detected.

*'''CRTC ''': This command reports the CRTC type. CRTC is the graphical chip of the Amstrad CPC. The CRTC test is based on Madram's implementation. It may not be the best implementation out there, but does the work as expected. It's useful to know installed CRTC type when dealing with demos that are dedicated to a single CRTC type.

*'''DEL ''': This command delete a file on disc. Be aware, no confirmation is asked to the user;!

*'''DELROM ''': This command is only compatible with RAMCARD and MEGAFLASH devices. It clears memory at specified ROM number.

*'''DIR ''': This command gives the list of files on disc. It shows files in the current user only. Available size in Kb is also reported. When this command requires multiple pages to display a long list of files, it will actually ask the user to press a key at each page-scroll. There is no filename sorting, files get displayed in order of apparition when parsing catalog information. The command supports Read-Only and Hidden files. It's interesting to mention that Hidden files are also treated and shown. If catalog appears to be a "cat art", then this command will be internally redirected to CATART command.

*'''DIRALL ''': This command performs like the DIR command, excepted it lists files for ALL users (from user 0 to 15). This is interesting to find files that are not under the current user. User of file is displayed as a prefix to the filename.

*'''DIRDEL ''': This command performs like the DIR command, excepted it lists deleted files. If a file has been recently deleted and that no write access on disc have been done, it's possible to retrieve original file content using the UNDEL command.

*'''DISCINFO ''': This gives information about disc format. It reports the name of the format, its capacity in Kb, the number of maximum files that can be managed, the single- or double-sided info, as also sectors and tracks identifiers. Many formats are supported, including those managed by PARADOS.

*'''HIDE ''': This command allows to hide a file from catalog. Of course, it will be still shown under QuickCMD (flagged as a Hidden file). When using CAT command, this file will be not reported (invisible) to the user. Files hidden can be shown back to catalog by using the SHOW command.

*'''INFO ''': This gives information about specified file. It reports its type (BASIC, PROTECTED BASIC, BINARY and ASCII). If the type allows it, it also reports the Load Address, the length of the file and its Execution Address.

*'''PUTROM ''': This command is only compatible with RAMCARD devices. First parameter is the ROM's filename, second parameter is the ROM number to write to. Specified file will be put onto the rom box. User will be asked to switch on/off the corresponding write DIP switch. It makes use of default implementation provided by Ram7 (the original author of the RAMCARD). It's advised to use ROMS command before using PUTROM to make sure to not overwrite a wanted and already installed ROM.

*'''REN ''': This command is used to rename a file. The first parameter is the new filename, the second parameter is the current filename to rename. Be aware;! REN command under BASIC use a reverse convention (old filename before new one). Such a reversion is used for DOS-like compatibility.

*'''READONLY ''': This command is used to set Read-Only attribute to a specified file. Files set as Read-Only can not be deleted till this attribute got removed.

*'''READWRITE ''': This command is used to set Read-Write attribute to a specified file (which is the default for a file). Files set as Read-Write can be deleted or overwritten.

*'''ROMS ''': This lists the installed ROMs on the system. On an unexpanded CPC, ROM 0 (BASIC) and ROM 7 (CPM ROM) are listed by default. This is useful to execute this command before putting a ROM on a rom box, to know which rom number should be used. The command shows, for each installed ROM, its internal name, its version and its type (foreground, background or extension).

*'''RSX ''': This command allows the execution of a RSX. First parameter is the RSX's name, other parameters are optional parameters to be sent to RSX. Optional parameters are always treated as string types. QuickCMD offers the functionality to execute a RSX as a command, so this command is used to override QuickCMD's internal commands. This is an example to make it clear;: let's say the Arnor's UTOPIA ROM has a RSX called HELP. In QuickCMD, if user types HELP, the internal QuickCMD's HELP command will be executed. User typing RSX HELP will then bypass the QuickCMD's HELP command and execute the Arnor's UTOPIA's HELP RSX.

*'''RUN ''': This command allows the execution of a file on disc. Supported file types are BASIC, PROTECTED BASIC or BINARY. It internally makes use of the BASIC's RUN command, so it's fully compliant with all existing programs. Like the RSX command, QuickCMD offers the functionality to type a filename as a command, so this command is used to override QuickCMD's internal commands. This is an example to make it clear;: let's say we have a file on disc called HELP.BAS. In QuickCMD, if user types HELP, the internal QuickCMD's HELP command will be executed. User typing RUN HELP will then bypass the QuickCMD's HELP command and execute the file HELP.BAS located on disc.

*'''SETUSER ''': This command is used to set user for a specified file. First parameter is filename, second parameter is the user.

*'''SHOW ''': This command is used to show (unhide) a file from catalog. Shown files can be hidden back from catalog by using the HIDE command.

*'''UNDEL ''': This command is used to undelete a file. This command will fail if a disc write access has been performed since the file has been deleted. Deleted files can be shown through the DIRDEL command.

*'''USER ''': This command is used to change current user. Default user is USER 0. Note that current user is also the one used in BASIC, so if you leave QuickCMD back to BASIC, then current user will remain active.

== Tips & Tricks ==

QuickCMD also offers some additional features that can make user's activity easier.

=== SHORTCUTS ===

In order to maximize user workflows, some shortcuts are provided to enhance productivity;:

*'''ENTER ''': if you press the ENTER key while the input command line is empty, then the screen will be cleared.

*'''TAB ''': this is probably one of the most interesting feature from QuickCMD. When you start typing a filename, if you press TAB key, QuickCMD will parse the catalog and try to autocomplete filename.

*'''TAB ''': if TAB key is pressed while the input command line is empty, then DIR command will be auto-typed (and executed).

*'''ESC ''': if ESC key is pressed, then the input command line's content will be cleared.

*'''ESC or CTRL+TAB ''': if ESC key or CTRL+TAB keys are pressed, then QuickCMD will exit back to BASIC.

== EXPECTED WORKFLOWS ==

The above shortcuts actually draws what should be one of the top uses of QuickCMD. It should be specifically interesting for new comers. If you find yourself a common workflow that is not listed here, feel free to report it to the author of this program;!

*'''The "fast DIR" ''': when your Amstrad CPC got started, user just has to press CTRL+TAB to enter QuickCMD. Then, TAB key is expected to execute DIR command. Once the user chose a file to execute, the first characters composing the filename can be typed and then the filename can be auto-completed using the TAB key. Finally, press ENTER key to execute file. This workflow is ultra-fast, you will get quickly used to the CTRL+TAB then TAB scheme;! Way faster than typing CAT command under BASIC then using SHIFT + arrow keys to select a filename then pressing COPY key to copy/paste filename then pressing CTRL+left arrow then pressing CTRL+ENTER to RUN" the file.

*'''BASIC is still your friend ''': QuickCMD is not a replacement for BASIC. BASIC has important features that QuickCMD does not support, and vice versa. It has been made easy to the user to quickly switch from BASIC to QuickCMD (and from QuickCMD to BASIC) by using the CTRL+TAB keys. Since QuickCMD is a ROM, you can deal with large BASIC programs or data stored in BANKs without any kind of alteration.

*'''Recommended third-party ROMs to be used with QuickCMD ''': QuickCMD is very well integrated with Arnor's ROMs. If you need a sector editor, use UTOPIA's DEDIT command. Use UTOPIA's MEDIT command for a memory editor. Use PROTEXT to edit your source files. Use MAXAM to program your assembly source-codes. By using all these powerful tools conjointly, you will be get an efficient manner to be creative with your CPC. This is a completely safe workflow, there have been many tests during QuickCMD implementation to make sure memory was not overwritten regarding various usage of HIMEM.

*'''Rediscover your library ! ''': One of the obvious strength of QuickCMD is the ability to show Hidden files on disc, as also quickly get information about a file or disc format. From a developer point of view, it's fun to be curious about how "proper" is a program, cf. is it composed by one or two files or is it composed by multiple small hidden files;? etc. Those things generally does not appear when using regular CAT command.

== History ==
===v2.3===
*Added command history
*ROMS command : Fixed a crash when listing ROMs with corrupted names
*Another critical problem (involving stability) has been fixed with direct drive parsing
*Renamed RSX to |Q (for even faster switching between BASIC and QuickCMD)
===v2.2===
*Added support for Bryce's MegaFlash
*Renamed RO and RW commands to READONLY and READWRITE
*Removed CRTC command
*Reset screen to QuickCMD’s default if external RSX changed video mode
*DELROM now clears a rom with &FF value (was using &00)
*Fixed: was overwriting first byte after HIMEM
*Fixed: not assuming anymore than Amsdos area is always at &A700
===v2.1===
*Correctly handles missing disc in drive for all commands
*PUTROM command now checks for BINARY file-type/correct size and displays information about the file to be put on RAMCARD
*DELROM command added to clear a ROM location
*DIR (and derivatives) now correctly reports file sizes for double-sided formats (Parados 80, etc) - thank you Richard!
*RSX command now accepts integer values (decimal and hexadecimal)
*RSX command now accepts quote " " for string-typed values (this allows to get space characters in strings by example)
*Internal code refactoring for smaller memory footprint
===v2.0===
This version is a complete rewrite of version 1.0 . While the initial version was featuring the interesting concepts featured back in version 2.0, it also pointed out some negative points;:

*'''too big for what it does ''': most of the program was written in C language. While being more productive that way, the program actually took too much memory.
*'''a ROM that isn't a ROM ''': the program was stored in a ROM. When executed, the content of the ROM was actually copied into RAM to make use of dynamic memory (it's impossible to write into a ROM). That was pretty bad, as the program was launched from BANK &C7 as also some parts of memory from fixed &8000 location.
*'''poor implementation ''': the program performed poorly. Most of disc operations were based on CAS CATALOG (the CAT command), that is slow and requires a 2Kb memory buffer.
*'''custom charset ''': the program made use of a custom integrated charset. Char output routine was efficient but took lots of memory space.
*'''and more... ''': many little details that were also polluting the code base.

Instead of maintaining a program with lots of lacks, decision has been took to completely rewrite the program with a different approach. Here are the most interesting points;:

*'''asm including C ''': instead of writing a C program with some assembly code inside, it has been more efficient to write the whole application using assembly code and implementing some high-level parts in C programming language. One of the best example for such a usage is the sector parsing part, that use a C's struct to iterate through the file entries.
*'''a ROM that is a ROM ''': writing a real ROM forced to use dynamic memory management. While this technic was interesting to implement, the most interesting part to point out is that QuickCMD's memory management got actually optimized to the maximum. The list of dynamic variables has to be kept as small as possible.
*'''and more... ''': many little details that, when written a second time, get suddenly clearer and much more maintainable.

== Credits ==

Program written by '''Arnaud Storq''' (www.norecess.net, 2011)
With the help of '''Kevin Thacker''' and '''Richard Wilson''',
CRTC type detection by '''Madram''',
RAMCARD management based on implementation from '''Ram7'''.

Many thanks to every person that reported me issues with version 1... This definitively helped a lot making a better implementation for version 2;!

==Files==

[[File:Quickcmd-v21.zip|QuickCMD v2.1, local mirror]]

[[File:Quickcmd-v20.zip|QuickCMD v2.0, local mirror]]

[[File:Quickcmd-v21.pdf|QuickCMD Instruction Manual, local mirror]]

==External Links==
[http://norecess.cpcscene.net/quickcmd.html NoRecess' QuickCMD page]

[[Category:Expansion_ROM]]

Programming:Filling memory with a byte

2018-03-17T23:15:44Z

Urusergi: /* Using the stack */

==Using LDIR==

From the '''The Unofficial Amstrad WWW Resource'''

<pre>
;; This code snippet will show one method to fill a block
;; of memory with a single data byte using Z80 assembly
;; language.

;;--------------------------------------------------

;; HL = start address of block
ld hl,&4000

;; DE = HL + 1
ld e,l
ld d,h
inc de

;; initialise first byte of block
;; with data byte (&00)
ld (hl),&00

;; BC = length of block in bytes
;; HL+BC-1 = end address of block

ld bc,&4000

;; fill memory
ldir

;;--------------------------------------------------

;; For each iteration of the LDIR command:
;;
;; 1. This command will copy the byte from the memory
;; address pointed to by HL to the memory address pointed to by DE.
;; i.e. (DE) = (HL).
;; 2. Then HL and DE will be incremented. BC will be decremented.
;;
;;
;; For the first byte:
;;
;; HL = start
;; DE = start+1
;; BC = length
;; (HL)=0
;;
;; For the second byte:
;;
;; HL = start + 1 (initialised to 0 by the previous iteration)
;; DE = start + 2
;; BC = length - 1
;;
;; For the third byte:
;;
;; HL = start + 2 (initialised to 0 by the previous iteration)
;; DE = start + 3
;; BC = length - 2
;;
;; etc....
</pre>

==Using the stack==

This method write bytes at a considerably faster rate by exploiting the speed of the stack pointer (SP) moving through RAM and its 2-byte steps. It is especially good for very rapidly clearing the screen.--[[User:Db6128|Db6128]] ([[User talk:Db6128|talk]]) 06:29, 13 December 2012 (EET)

<pre>
; Save the stack pointer
ld (SAVE_SP),sp ; Only remove if you're sure you don't need the stack
ld sp,FINAL_ADDRESS+1 ; e.g. to fill from &C000 to &FFFF (&4000 bytes), set SP to &FFFF+1 = &0000

; Define the region of RAM to be filled
ld hl,YOUR_BYTE_1*&100 + YOUR_BYTE_2 ; Use HL or whichever 16-bit register you prefer
ld de,LENGTH_TO_FILL/2 ; divided by 2 because DE is 2 bytes wide and PUSH pushes both

; Set up a fast 16-bit loop counter
ld b,e ; This method takes advantage of the fact that DJNZ leaves B as 0, which subsequent DJNZs see as 256
dec de ; B = (length/2) MOD 256, so 0 = a 512-byte block
inc d ; D = the number of 512-byte blocks to write, or just = 1 if the length is <512
; Of course, if you know the length ahead of run-time, you can set B and D directly in your ASM

; Fill the memory
PUSHLOOP:
push hl ; Writes HL to (SP-2) and DECs SP by 2.
; For even more speed, use multiple PUSH HLs in a row (I like 8, = &10 bytes) and adjust counters to match
djnz PUSHLOOP
dec d
jr nz,PUSHLOOP

; Restore the stack pointer
SAVE_SP equ $+1
ld SP,&9999 ; &9999 will be replaced by the actual previous value
</pre>

[[Category:Programming]]

Programming:Fast plot

2018-03-17T18:04:07Z

Urusergi: /* Fast plotting routine for MODE 1 */

== Fast plotting routine for MODE 0 ==

Converted from the Mode 1 routine by [[User:Executioner|The Executioner]]

'''Input:''' DE = ''X (0..159)'', HL = ''Y (0..199)''

<pre>
CMASK EQU &B338 ;Address for colormask
;664/6128: &B6A3

FPLOT LD A, L ;A = Lowbyte Y
AND %00000111 ;isolate Bit 0..2
LD H, A ;= y MOD 8 to H
XOR L ;A = Bit 3..7 of Y
LD L, A ;= (Y\8)*8 to L
LD C, A ;store in C
LD B, &60 ;B = &C0\2 = Highbyte Screenstart\2

ADD HL, HL ;HL * 2
ADD HL, HL ;HL * 4
ADD HL, BC ;+ BC = Startaddress
ADD HL, HL ;of the raster line

SRL E ;calculate X\2, because 2 pixel per byte, Carry is X MOD 2

LD C, %10101010 ;Bitmask for MODE 0
JR NC, NSHIFT ;-> = 0, no shift
SHIFT LD C, %01010101 ;other bitmask for right pixel

NSHIFT ADD HL, DE ;+ HL = Screenaddress
LD A, (CMASK) ;get color mask
XOR (HL) ;XOR screenbyte
AND C ;AND bitmask
XOR (HL) ;XOR screenbyte
LD (HL), A ;new screenbyte
RET ;done
</pre>

== Fast plotting routine for MODE 1 ==

This routine is approx. 6 times faster than the OS routine GRA PLOT, because it is dependent to MODE 1 and doesn't perform range checks. It can draw 10500 pixels per second.

'''Input:''' DE = ''X (0..319)'', HL = ''Y (0..199)''

<pre>
CMASK EQU &B338 ;Address for colormask
;664/6128: &B6A3

FPLOT LD A, L ;A = Lowbyte Y
AND %00000111 ;isolate Bit 0..2
LD H, A ;= y MOD 8 to H
XOR L ;A = Bit 3..7 of Y
LD L, A ;= (Y\8)*8 to L
LD C, A ;store in C
LD B, &60 ;B = &C0\2 = Highbyte Screenstart\2

ADD HL, HL ;HL * 2
ADD HL, HL ;HL * 4
ADD HL, BC ;+ BC = Startaddress
ADD HL, HL ;of the raster line

LD A, E ;Lowbyte X to A
SRL D ;calculate X\4, because
RR E ;4 pixel per byte
SRL E
ADD HL, DE ;+ HL = Screenaddress

LD C, %10001000 ;Bitmask for MODE 1
AND %00000011 ;A = X MOD 4
JR Z, NSHIFT ;-> = 0, no shift
SHIFT SRL C ;move bitmask to pixel
DEC A ;loop counter
JR NZ,SHIFT ;-position

NSHIFT LD A, (CMASK) ;get color mask
XOR (HL) ;XOR screenbyte
AND C ;AND bitmask
XOR (HL) ;XOR screenbyte
LD (HL), A ;new screenbyte
RET ;done
</pre>

== Fast plotting routine for MODE 2 ==

And the MODE 2 routine. Perhaps this could be improved since there are only two colours, and the pixel shift may need to operate up to 7 times (so perhaps a table would average out better).

<pre>
CMASK EQU &B338 ;Address for colormask
;664/6128 - &B6A3

FPLOT LD A, L ;A = Lowbyte Y
AND %00000111 ;isolate Bit 0..2
LD H, A ;= y MOD 8 to H
XOR L ;A = Bit 3..7 of Y
LD L, A ;= (Y\8)*8 to L
LD C, A ;store in C
LD B, &60 ;B = &C0\2 = Highbyte Screenstart\2

ADD HL, HL ;HL * 2
ADD HL, HL ;HL * 4
ADD HL, BC ;+ BC = Startaddress
ADD HL, HL ;of the raster line

LD A, E ;Lowbyte X to A
SRL D ;calculate X\8, because
RR E ;8 pixel per byte
SRL D
RR E
SRL E
ADD HL,DE ;+ HL = Screenaddress

LD C,%10000000 ;Bitmask for MODE 2
AND %00000111 ;A = X MOD 8
JR Z, NSHIFT ;-> = 0, no shift

SHIFT SRL C ;move bitmask to pixel
DEC A ;loop counter
JR NZ,SHIFT ;-position

NSHIFT LD A, (CMASK) ;get color mask
XOR (HL) ;XOR screenbyte
AND C ;AND bitmask
XOR (HL) ;XOR screenbyte
LD (HL), A ;new screenbyte
RET ;done
</pre>

[[Category:Programming]]

Talk:Programming:Fast plot

2018-03-17T17:59:08Z

Urusergi: Blanked the page

Programming:Fast plot

2018-03-17T17:52:59Z

Urusergi: /* Fast plotting routine for MODE 2 */

== Fast plotting routine for MODE 0 ==

Converted from the Mode 1 routine by [[User:Executioner|The Executioner]]

'''Input:''' DE = ''X (0..159)'', HL = ''Y (0..199)''

<pre>
CMASK EQU &B338 ;Address for colormask
;664/6128: &B6A3

FPLOT LD A, L ;A = Lowbyte Y
AND %00000111 ;isolate Bit 0..2
LD H, A ;= y MOD 8 to H
XOR L ;A = Bit 3..7 of Y
LD L, A ;= (Y\8)*8 to L
LD C, A ;store in C
LD B, &60 ;B = &C0\2 = Highbyte Screenstart\2

ADD HL, HL ;HL * 2
ADD HL, HL ;HL * 4
ADD HL, BC ;+ BC = Startaddress
ADD HL, HL ;of the raster line

SRL E ;calculate X\2, because 2 pixel per byte, Carry is X MOD 2

LD C, %10101010 ;Bitmask for MODE 0
JR NC, NSHIFT ;-> = 0, no shift
SHIFT LD C, %01010101 ;other bitmask for right pixel

NSHIFT ADD HL, DE ;+ HL = Screenaddress
LD A, (CMASK) ;get color mask
XOR (HL) ;XOR screenbyte
AND C ;AND bitmask
XOR (HL) ;XOR screenbyte
LD (HL), A ;new screenbyte
RET ;done
</pre>

== Fast plotting routine for MODE 1 ==

This routine is approx. 6 times faster than the OS routine GRA PLOT, because it is dpendent to MODE 1 and doesn't perform range checks. It can draw 10500 pixels per second.

'''Input:''' DE = ''X (0..319)'', HL = ''Y (0..199)''

<pre>
CMASK EQU &B338 ;Address for colormask
;664/6128: &B6A3

FPLOT LD A, L ;A = Lowbyte Y
AND %00000111 ;isolate Bit 0..2
LD H, A ;= y MOD 8 to H
XOR L ;A = Bit 3..7 of Y
LD L, A ;= (Y\8)*8 to L
LD C, A ;store in C
LD B, &60 ;B = &C0\2 = Highbyte Screenstart\2

ADD HL, HL ;HL * 2
ADD HL, HL ;HL * 4
ADD HL, BC ;+ BC = Startaddress
ADD HL, HL ;of the raster line

LD A, E ;Lowbyte X to A
SRL D ;calculate X\4, because
RR E ;4 pixel per byte
SRL E
ADD HL, DE ;+ HL = Screenaddress

LD C, %10001000 ;Bitmask for MODE 1
AND %00000011 ;A = X MOD 4
JR Z, NSHIFT ;-> = 0, no shift
SHIFT SRL C ;move bitmask to pixel
DEC A ;loop counter
JR NZ,SHIFT ;-position

NSHIFT LD A, (CMASK) ;get color mask
XOR (HL) ;XOR screenbyte
AND C ;AND bitmask
XOR (HL) ;XOR screenbyte
LD (HL), A ;new screenbyte
RET ;done
</pre>

== Fast plotting routine for MODE 2 ==

And the MODE 2 routine. Perhaps this could be improved since there are only two colours, and the pixel shift may need to operate up to 7 times (so perhaps a table would average out better).

<pre>
CMASK EQU &B338 ;Address for colormask
;664/6128 - &B6A3

FPLOT LD A, L ;A = Lowbyte Y
AND %00000111 ;isolate Bit 0..2
LD H, A ;= y MOD 8 to H
XOR L ;A = Bit 3..7 of Y
LD L, A ;= (Y\8)*8 to L
LD C, A ;store in C
LD B, &60 ;B = &C0\2 = Highbyte Screenstart\2

ADD HL, HL ;HL * 2
ADD HL, HL ;HL * 4
ADD HL, BC ;+ BC = Startaddress
ADD HL, HL ;of the raster line

LD A, E ;Lowbyte X to A
SRL D ;calculate X\8, because
RR E ;8 pixel per byte
SRL D
RR E
SRL E
ADD HL,DE ;+ HL = Screenaddress

LD C,%10000000 ;Bitmask for MODE 2
AND %00000111 ;A = X MOD 8
JR Z, NSHIFT ;-> = 0, no shift

SHIFT SRL C ;move bitmask to pixel
DEC A ;loop counter
JR NZ,SHIFT ;-position

NSHIFT LD A, (CMASK) ;get color mask
XOR (HL) ;XOR screenbyte
AND C ;AND bitmask
XOR (HL) ;XOR screenbyte
LD (HL), A ;new screenbyte
RET ;done
</pre>

[[Category:Programming]]

Talk:Programming:Fast plot

2010-03-11T15:09:52Z

Urusergi:

The routines in MODE 0 and MODE 2 will not work properly due to lack of a command:

''ADD HL, HL ;HL * 2''

''ADD HL, HL ;HL * 2''

''ADD HL, BC ;+ BC = Startaddress''

''ADD HL, HL ;of the raster line''

'''LD A, E'''

Talk:Programming:Fast plot

2010-03-11T15:00:18Z

Urusergi:

The routines in MODE 0 and MODE 2 will not work properly due to lack of a command:

ADD HL, HL ;HL * 2
ADD HL, HL ;HL * 4
ADD HL, BC ;+ BC = Startaddress
ADD HL, HL ;of the raster line

'''LD A, E '''

Talk:Programming:Fast plot

2010-03-11T14:49:08Z

Urusergi: Created page with 'The routines in MODE 0 and MODE 2 will not work properly due to lack of a command: ADD HL, HL ;HL * 2 ADD HL, HL ;HL * 4 ADD HL, BC ;+ BC = Startaddress ADD HL, HL ;of the r…'