BBC MICROBASE SERIES BBC 6502 Machine Code by Geoff Cox ---------------------------------- This series was first published on Micronet between April and October 1991 The BBC Micro Operating System Part One: The moving electron writes ------------------------------------ In the last series we reviewed the basics of machine code programming using the 6502. You will have noticed that not too many examples of programming were given. This is because there are two levels of programming on any machine, machine level and operating system level. Operating Systems ----------------- An operating system is basically a group of routines that sit between the user and the electronics of the computer. To illustrate what an operating system does we have to turn briefly from the path of the series. We'll imagine that you want to write the letter A on the screen of your monitor. First we have to work out the shape of the character and slice it horizontally into eight sections, one for each of eight screen scanning lines on the monitor. Now we need to detect when the frame synchronising pulse for the monitor is sent by the computer. Next we need to count the line synchronising pulses to find the one corresponding to the start of the first line of the character. Then we must time from this pulse to the start of the first line of the character, turn on the appropriate electron guns in the monitor and turn them off at the correct time for the end of the of the character. Finally we have a few microseconds to do it all again for the next line. That's more or less what happens fifty times a second on your monitor screen. Mapped Screens -------------- This makes even the easiest task very complex. We can make life easier by storing a picture or map of the screen in memory and writing the character shape to the appropriate map locations. The map can then be scanned in synchronisation with the electron beam on the monitor. This can either be via a clever piece of electronics or a software routine. To illustrate the BBC map, type the following program on any 6502- based BBC without screen RAM shadowing. 10 MODE 0 20 ?&7D00=65 You should see two little white dots towards the bottom right of the screen. Now two dots are not the letter A so if we want to write A we have to designthe character and write it to the map. This program does just that. 10 MODE 0 20 FOR A=&7D00 TO &7D07 30 READ B 40 ?A=B 50 NEXT 60 DATA &3C, &66, &66, &7E 70 DATA &66, &66, &66, &00 The sharp-eyed among you will have spotted something a little odd here. The screen seems to be arranged in blocks of eight bytes in this mode. Don't worry about this - it simply makes character table design simpler. Character Tables ---------------- We can make life even easier by designing a set of characters and putting them in an area of memory where they can be looked up. In the BBC B this area is in ROM starting at &C000. A quick diversion here. If we have to have a series of character designs in memory it helps to have a standard method of accessing them. The standard character ordering is called ASCII. A space has ASCII number 32 and this is the first "printable" character in the set. The last is 127 (Delete). There are eight bytes in each character matrix so the design for any character is at &C000+(8*(ASCII - 32)). This program examines the ROM character table and shows how characters are arranged. 10 MODE 0 20 PRINT "CHARACTER ?" 30 A$=GET$ 40 PRINT A$ 50 START=(8(ASC(A$)-32))+&C000 60 FIN=START+7 70 FOR BYTE=START TO FIN 80 PEEK=?BYTE 90 PROC_BIN 100 PRINT~BYTE;TAB(15);~?BYTE;TAB(20); 110 NEXT 120 END 130 DEFPROC_BIN 140 A$="" 150 FOR BIT=7 TO 0 STEP-1 160 X=(PEEK AND 2^BIT) 170 IF X>1 THEN A$=A$+"" ELSE A$=A$+"." 180 NEXT 190 ENDPROC As you will often want to write characters on the screen it makes a lot of sense to have a little routine to take a character from a register and print it on the screen. The routine will look up a character in the table and print it to the appropriate position on the screen. There will also need to be a record of the cursor position on the screen. Routines for printing and moving a cursor on the screen will also be useful. You could, of course, write all of these routines yourself as part of every program but as the computer manufacturer has to provide them in order to tell you the machine is working he usually leaves an access point for you to use the routines yourself. Incidentally if you rewrite the first program but change line 10 to read MODE 7 you will see a letter A on the screen. This is an example of clever electronics. A chip on the BBC board contains a character generator. Instead of the character design being stored in the screen map the character's ASCII value is stored. This is read by the electronics and used to generate characters directly on the screen. This allows a 40 x 80 text and block graphics screen to be generated in just 1K of RAM. Using the Operating System -------------------------- The screen handling routines and several others make up an operating system. In the BBC micro the series of routines that write a character on the screen can be accessed though a point called OSWRCH at &FFFE. So instead of having to design characters, time lines and do all of the other things, you can output a letter A to the screen simply using: LDA #65 JSR &FFEE ;OSWRCH and leave the operating system to do the rest. BBC 6502 Machine Code Part Two: In the beginning -------------------------- Last week we looked at the reasons for an operating system and how it can simplify the programmer's task. Unfortunately you will not always be able to use the operating system. There may not be a suitable routine or it may be too slow. In these cases you have to write to the device itself. So to continue our look at machine code we need to examine programming with device handling and the operating system. This series will attempt to kill two birds with one stone by taking avery close look at Acorn's OS 1.20 used on Model Bs. This changed little for the B+ and Master so while the routines may be in a slightly different place the basic system will be the same. The Master uses 65C02 code which has a few extra instructions so there may be some differences in the length of the code. What you will need ------------------ A disassembler or machine code monitor that can handle 6502 or 65C02 codes. If If you don't have either you can use: PRINT ~?address to get the hexadecimal codes which you can then look up in the back of the BBC User Guide to get the relevant command. Suitable Monitors are EXMON, BBC Monitor or the SYSTEM monitor. (I use "Maxim" - Ed.) If you have a single- stepping monitor like one of these, you will be able to trace some of the routines for yourself. For this series we will use standard 6502 mnemonics except that DB and DW will be used to show byte assignments rather than EQUS, EQUW and EQUB. This is because the disassembler I am using produces these codes and it's a lot easier to follow than convoluted BBC-type statements. First things first ------------------ Remember that an operating system is not a program in the usual sense. Normal programs have a defined entry and exit routines. An operating system can have a large number of entry and exit points as well as interlocking routines. So to examine the operating system we need a starting point. The 6502 regards memory as a series of 256-byte pages 0 to &FF (255). Any address can be considered to be a page number plus an offset within the page. Both figures can be represented by a single byte. So address &FF01 is on Page &FF offset 01. The concept of offsets is very useful if you ever get involved in 80n86 programming. The BBC Manual gives a series of system entry points on page FF. Most of these are indirected through Page 2 and as we cannot guarantee what the contents of Page 2 should be (the vectors can be and are changed) these are useless as starting points. This leaves three sensible entry points. 6502 Vectors FFFA DW &0D00 ;NMI address FFFC DW &D9CD ;RESET address FFFE DW &DC1C ;IRQ address The NMI address is in RAM so no joy there, but the other two look fine. The best is RESET as this is where the machine starts when it is turned on or BREAK is pressed. In the case of Model B and OS 1.20 that address is &D9CD, so what happens? In the beginning ---------------- Reset can be effected by turning on the computer or pressing BREAK. If it is a power-up then the system VIA and processor are reset electronically. If this is a power on situation then nothing has been set up. The first thing that happens when power is turned on is that the 6522 VIAs, the processor and the floppy disc controller are reset. This is done by means of one of three printed circuit tracks. The tracks are RSTA, RST and NOTRESET. RSTA is only connected to the system 6522 Versatile Interface adaptor (VIA). This operates through a little resistor/capacitor circuit that only works when the power is turned on. The effect of this is that the 6522 System VIA Interrupt Enable Register (IER) bits 0 to 6 will be clear (0) only if the reset is caused by a power on condition. If the Reset is caused by BREAK being pressed then the machine must have been on and therefore one or more of the System VIA IER bits will be set (to 1). If one or more bits are set then bit 7 of the VIA will also be set. This is used to determine the type of Reset. So let's look at the operating system more closely. D9CD LDA #&40 ;set NMI first instruction to RTI D9CF STA &0D00 ;NMI RAM start RESET is the ultimate Act of God as far as the machine is concerned. Anything could be happening so the operating system has to clean up the system as its first act. These first instructions just make sure that if a disc is running no more information will be read or written from or to the disc. This illustrates why you shouldn't press BREAK when a disc is being accessed! The next section sets up the stack: + D9D2 SEI ;disable interrupts just in case D9D3 CLD ;clear decimal flag D9D4 LDX #&FF ;reset stack to where it should be D9D6 TXS ;(&1FF) Next find out if a power-up reset or a BREAK press by examining the System VIA IER register. D9D7 LDA &FE4E ;read interrupt enable register of the system VIA D9DA ASL ;shift bit 7 into carry D9DB PHA ;save what's left D9DC BEQ &D9E7 ;if Power up A=0 so go to D9E7 to clear memory That's probably enough for this time. Don't worry! I don't intend to do a complete disassembly of the operating system in this series but we will follow through the power-on sequence to the end because a lot of interesting things happen at this time. We'll take a look at D9E7 and the next routine in this sequence (D9DE) in the next part. BBC 6502 Machine Code Part Three: Cleaning up the mess -------------------------------- In the last part we looked at what happens when you press BREAK or switch on the machine. We'll now continue with a look at an undocumented (at least officially) routine. The byte at &258 can be used to contain information about what the machine should do if BREAK is pressed. FX200,n is used to set this byte. If n=2 or n=3 then the memory must be cleared. This is often used in program protection. D9DE LDA &0258 ;else if BREAK pressed read BREAK Action flags (set by FX200,n) D9E1 LSR ;divide by 2 D9E2 CMP #&01 ;if &0258 <> 2 or 3 D9E4 BNE &DA03 ;then Goto &DA03 D9E6 LSR ;divide A by 2 again (A=0 if FX200,2/3 else A=n/4 Pages 4-&7F are cleared by a simple loop if &258=2 or 3 or it is a power on reset. Look out for the clever way of avoiding problems on 16K machines. D9E7 LDX #&04 ;get page to start clearance from (4) D9E9 STX &01 ;store it in ZP 01 D9EB STA &00 ;store A at 00 D9ED TAY ;and in Y to set loop counter ;LOOP STARTS D9EE STA (&00),Y ;clear RAM D9F0 CMP &01 ;until page address (in &01) =0 D9F2 BEQ &D9FD ; D9F4 INY ;increment pointer D9F5 BNE &D9EE ;if not zero loop round again D9F7 INY ;else increment again (Y=1) this avoids overwriting the RTI ;instruction at &D00 D9F8 INX ;increment X D9F9 INC &01 ;increment &01 D9FB BPL &D9EE ;loop until Page (in 01)=&80 then exit Note that RAM addressing for 16K loops around to &4000=&00 hence the checking of &01 for 00. This avoids overwriting zero page on BREAK which would cause the machine to crash! D9FD STX &028E ;writes marker for available RAM 40 =16K,80=32 DA00 STX &0284 ;write soft key consistency flag This routine shows the basic structure of a loop. Those of you who program in BASIC will recognise it as a very simple structure: 10 A=A+1 20 IF A<20 GOTO 10 The loop uses zero page addressing with the target address in 00 and 01 (Page) and the index in Y. The loop is exited when the value in 01 becomes negative. Remember that all values between 0 and &7F are considered to be positive, so the BPL instruction can be used to exit the loop at page &80, the first negative number. This is the first of the useful loop techniques we'll see in this series. Notice that the first byte of each page is left unchanged. This is useful if you want information to survive a BREAK of this type. This clearing of memory is not normally carried out. Next week we'll have a look at the normal RESET path. BBC 6502 Machine Code Part Four: Cleaning up even more mess ------------------------------------- As we saw last week, a normal warm reset avoids the memory clearance and proceeds to set up the System VIA. DA03 LDX #&0F ;set PORT B data direction register to output on bits ;0-3 and input bits 4-7 DA05 STX &FE42 ; The next bit is a little more complicated and is intimately bound up with hardware. The function is to set up the addressable latch IC 32 for peripherals via PORT B. The latch value is written by writing the value to &FE40 bits 0 to 2 and either a 1 or 0 to bit 3. Writing the value + 8 therefore writes a 1 to the latched address, otherwise a 0 is written. Value Peripheral Effect + 0 8 0 Sound chip Enabled Disabled Speech Chip 1 (RS) Low High 2 (WS) Low High 2 (WS) Low High 3 Keyboard Write Disabled Enabled 4 C0 address modifier Low High 5 C1 address modifier Low High 6 Caps LED On Off 7 Shift LED On Off C0 and C1 are involved with hardware scroll screen address. ;X=&F on entry DA08 DEX ;loop start DA09 STX &FE40 ;Write latch IC32 DA0C CPX #&09 ;Is it 9? DA0E BCS &DA08 ;If not go back and do it again ;X=8 at this point ;Caps Lock On, SHIFT Lock undetermined ;Keyboard Autoscan on ;Sound disabled (may still sound) Next the keyboard is scanned to determine the values of the keyboard links and whether a Ctrl-Break has been performed. Remember that although we have spent a lot of time reading this, we are probably less than 200 microseconds after BREAK was pressed. The check for Ctrl-Break is effectively looking for simultaneous keypresses. DA10 INX ;X=9 DA11 TXA ;A=X DA12 JSR &F02A ;Interrogate keyboard DA15 CPX #&80 ;for keyboard links 9-2 and CTRL key (1) DA17 ROR &FC ;rotate MSB into bit 7 of &FC DA19 TAX ;Get back value of X for loop DA1A DEX ;Decrement it DA1B BNE &DA11 ;and if >0 do loop again ;On exit if Carry set link 3 is made ;link 2 = bit 0 of &FC and so on ;If CTRL pressed bit 7 of &FC=1 X=0 DA1D STX &028D ;Clear last BREAK flag DA20 ROL &FC ;CTRL is now in carry &FC is keyboard links DA22 JSR &EEEB ;Set LEDs ;Carry set on entry is in bit 7 of A on exit DA25 ROR ;Get carry back into carry flag To review what the operating system has done so far, about 400 microseconds after a BREAK press or about 2 milliseconds from a power on. Memory may have been cleared, NMIs have been short circuited, IRQs disabled. The keyboard has been scanned for made links and for Ctrl being pressed. We have also located two important and undocumented subroutines: &F02A toscan the keyboard and &EEEB to set the keyboard LEDs. The F02A routine scans for the key whose code is in X being pressed: F02A LDY #&03 ;Stop Auto scan F02C STY &FE40 ;by writing to system VIA F02F LDY #&7F ;Set bits 0 to 6 of port A to input on bit 7. ;Output on bits 0 to 6 F031 STY &FE43 ; F034 STX &FE4F ;Write X to Port A system VIA (key to check) F037 LDX &FE4F ;Read back &80 if key pressed (M set) F03A RTS ;And return The routine at &EEEB switches on the selected keyboard lights. EEEB PHP ;Save flags EEEC LDA &025A ;Read keyboard status ;Bit 7=1 shift enabled ;Bit 6=1 control pressed ;Bit 5 =0 shift lock ;Bit 4 =0 Caps lock ;Bit 3 =1 shift pressed EEEF LSR ;Shift Caps bit into bit 3 EEF0 AND #&18 ;Mask out all but 4 and 3 EEF2 ORA #&06 ;Returns 6 if caps lock OFF &E if on. ;Remember add 8 to the value for the addressable ;latch to send a 1. EEF4 STA &FE40 ;Turn on or off caps light if required EEF7 LSR ;Bring shift bit into bit 3 EEF8 ORA #&07 ; EEFA STA &FE40 ;Turn on or off shift lock light EEFD JSR &F12E ;Set keyboard counter EF00 PLA ;Get back flags into A EF01 RTS ;Return In this part we've had a look at subroutines using JSR and RTS, the machine code equivalent of GOSUB, PROC or FN. Subroutines are often used in machine code to perform such frequently needed functions as scanning a keyboard or turning on and off lights. We've also discovered that the byte at &25A contains the keyboard status. Try changing it for yourself. You can therefore use OR and AND to set the shift and Caps lock status of the machine for a particular program. Next week we'll examine setting up the default vector table in memory. BBC 6502 Machine Code Part Five: Vectors Victor ------------------------- The next stage is to set up the vectors on page 2. DA26 LDX #&9C ; DA28 LDY #&8D ; DA2A PLA ;Get back A from &D9DB DA2B BEQ &DA36 ;If A=0 power up reset so go to DA36 with X=&9C ;Y=&8D DA2D LDY #&7E ;else let Y=&7E DA2F BCC &DA42 ;and if not CTRL- BREAK go to DA42 for a WARM RESET DA31 LDY #&87 ;else Y=&87 COLD RESET DA33 INC &028D ;&28D=1 DA36 INC &028D ;&28D=&28D+1 DA39 LDA &FC ;Get keyboard links set DA3B EOR #&FF ;Invert DA3D STA &028F ;and store at &28F DA40 LDX #&90 ;X=&90 What we have done is to set up the high water marks for the reset of vectors. &28D=0 Warm reset, X=&9C, Y=&7E &28D=1 Power up , X=&90, Y=&8D &28D=2 Cold reset, X=&9C, Y=&87 DA42 LDA #&00 ;A=0 DA44 CPX #&CE ;zero &200+X to &2CD DA46 BCC &DA4A ; DA48 LDA #&FF ;then set &2CE to &2FF to &FF DA4A STA &0200,X ; DA4D INX ; DA4E BNE &DA44 ; ;A=&FF X=0 This is another IF-GOTO loop, but in this case it is a double function loop. The test at DA44 to DA46 means that A is 0 only for values of X between the high water mark and &CD. Above this value A is set to &FF by the instruction at &DA48. This saves a few bytes of space, essential when writing a tightly-filled ROM. The next instructions set up the printer port. The only reason for doing this now is to save two bytes. A must be &FF at this point so it is used to set up the User VIA for outputs as the printer port. DA50 STA &FE63 ;Set port A of user VIA to all outputs (printer out) DA53 TXA ;A=0 DA54 LDX #&E2 ;X=&E2 START OF LOOP DA56 STA &00,X ;set zero page addresses &E2 to &FF to zero DA58 INX ; DA59 BNE &DA56 ;X=0 Now set up the vectors in page 2 from the table at &D940: DA5B LDA &D93F,Y ;copy data from &D93F+Y DA5E STA &01FF,Y ;to &1FF+Y DA61 DEY ;until DA62 BNE &DA5B ;1FF+Y=&200 Note that this is a decrementing loop which, for loops ending when an index register reaches zero, is faster and shorter because no compare is needed. More space saved! Now the RS423 port is set up via a subroutine affecting the ACIA. (Asynchronous Communications Interface Adaptor) DA64 LDA #&62 ;A=&62 DA66 STA &ED ;store in &ED DA68 JSR &FB0A ;set up ACIA ;X=0 Now Acorn clears the interrupt and enable registers of both VIAs. DA6B LDA #&7F ;bit 7 is 0! DA6D INX ; DA6E STA &FE4D,X ; DA71 STA &FE6D,X ; DA74 DEX ; DA75 BPL &DA6E ; ;This loop only has two passes as X=0 on entry. DA77 CLI ;Briefly allow interrupts to clear anything ;pending DA78 SEI ;Disallow again NB: all VIA IRQs are disabled DA79 BIT &FC ;If bit 6=1 then JSR &F055 as there must be a ;hardware interrupt! DA7B BVC &DA80 ;else DA80 DA7D JSR &F055 ; What have we here? Another undocumented routine. If bit 6 of &FC is set there must have been a hardware interrupt when the SEI occurred. From the circuit diagram the only place that this IRQ could have come from is the 1MHz bus - let's have a look at the routine at &F055. F055 JMP (&FDFE) ;Jim paged entry vector So we jump to some piece of hardware on the 1MHz bus. This would probably be a ROM which would take over the system at power on and Break. This has some very interesting applications. It was designed by Acorn to provide a crude Econet facility to allow a batch of machines to be functionally tested without the need to install a full Econet kit. Next week we shall examine the VIA bus. BBC 6502 Machine Code Part Six: The VI bus -------------------- The next interesting routine we find in the BBC operating system is the one that sets up the system VIA interrupts. It is located at &DA80. Refer to the manual for the meanings of Sheila addresses. DA80 LDX #&F2 ;Enable interrupts 1,4,5,6 of system VIA DA82 STX &FE4E ; ;0 Keyboard enabled as needed ;1 Frame sync pulse ;4 End of A/D conversion ;5 T2 counter (for speech) ;6 T1 counter (10 mSec intervals) DA85 LDX #&04 ;set system VIA PCR DA87 STX &FE4C ; ;CA1 Interrupt on negative edge (Frame sync) ;CA2 Handshake output for keyboard ;CB1 Interrupt on negative edge (end of conversion) ;CB2 Negative edge (Light pen strobe) DA8A LDA #&60 ;Set system VIA ACR DA8C STA &FE4B ; ;Disable latching ;Disable shift register ;T1 counter continuous interrupts ;T2 counter timed interrupt DA8F LDA #&0E ;Set system VIA T1 counter (low) DA91 STA &FE46 ; ;This becomes effective when T1 hi set DA94 STA &FE6C ;Set user VIA PCR ;CA1 interrupt on -ve edge (Printer Acknowledge) DA80 LDX #&F2 ;enable interrupts ;CA2 High output (printer strobe) ;CB1 Interrupt on -ve edge (user port) ;CB2 Negative edge (user port) DA97 STA &FEC0 ;Set up A/D converter Bits 0 and 1 determine ;channel selected ;If Bit 3=0 it is set for an 8-bit conversion. ;If bit 3=1 12-bit conversion. Now although the machine now knows how much RAM it has it still doesn't know if it's a Model A or Model B, so it does not know if a user VIA is present at &FE60-FE6F. The next routine tests for the presence of a user VIA. The system timers are then set up to interrupt every 10mSec. Sound channels are cleared and the serial ULA is set up. Then the function keys are reset. Now we need a catalogue of sideways ROMS. This is not a catalogue in the conventional sense as the ROM title is always at the same place in the ROM itself and can be read from there. It is a catalogue of the ROM types and positions. There is a ROM latch at &FE30. Writing a number between 0 and 15 to this switches the corresponding ROM into the area between &8000 and &BFFF. A short subroutine does this and maintains a copy of the current ROM in zero page at location &F4. ;on entry X=required ROM number DC16 STX &F4 ;RAM copy of ROM latch DC18 STX &FE30 ;Write to ROM latch DC1B RTS ;and return You should use this subroutine if you want to switch ROMs. Now we can look at the ROM cataloguing routines; A ROM is considered to be valid if it contains a string identical to astring at location &DF0C in the Operating System ROM. DF0C DB ')C(' ; DF0F DB 0 ; The location of this string is pointed to by an offset byte located at &8007. ;X=0 on entry DABD JSR &DC16 ;Set up ROM latch and RAM copy to X DAC0 LDX #&03 ;Set X to point to offset in table DA80 LDX #&F2 ;Enable interrupts DAC2 LDY &8007 ;Get copyright offset from ROM DAC5 LDA &8000,Y ;Get first byte DAC8 CMP &DF0C,X ;Compare it with table byte DACB BNE &DAFB ;If not the same then goto DAFB DACD INY ;Point to next byte DACE DEX ;(s) DACF BPL &DAC5 ;and if still +ve go back to check next byte. ;This point is reached if 4 bytes indicate ;valid ROM Next the first 1K of each ROM is checked against higher priority ROMs to ensure that there are no matches. If a match is found, the lower priority ROM is ignored. A ROM type byte is located at &8006. A catalogue of these bytes is held at &2A1-&2B0. If bit 7 of this byte is 0 then the ROM is BASIC. The position of this ROM is stored at &24B. Now the ROMs are catalogued it is time to set up the speech system and screen. More about that next week. BBC 6502 Machine Code Part Seven: Talk to me ---------------------- The operating system start-up routines next checks the SPEECH system. At this point the X register is set to 16 (&10) by previous routines. This is one of the reasons why this routine is inserted here. Setting X to the required value would use two more bytes. This is not much space but it can make the difference between all of the OS fitting into a single ROM and a complete hardware or software redesign. DB11 BIT &FE40 ;If bit 7 low then we have speech system fitted DB14 BMI &DB27 ;else goto DB27 for screen set up routine. DB16 DEC &027B ;(027B)=&FF a RAM flag that indicates that a speech ;chip is present. DB19 LDY #&FF ;Y=&FF DB1B JSR &EE7F ;Initialise speech generator DB1E DEX ;via this DB1F BNE &DB19 ;loop Now X = 0 so: DB21 STX &FE48 ;Set T2 timer for speech DB24 STX &FE49 ; Screen set-up ------------- X=0 on entry to this routine which gets the default screen mode and then goes off to the screen setup routine. DB27 LDA &028F ;Get back start up options (mode) DB2A JSR &C300 ;then jump to initialise screen. One of the things that I wondered when I got a BBC was how the RESET key could possibly act as a soft key. As we all know BREAK acts as soft key 10. But the keyboard buffer is cleared by the Reset. Tucked away is the five-byte routine that makes the BREAK key act as soft key 10. Soft keys work by inserting a byte greater than 127 into the keyboard buffer. &CA is the code for key 10. DB2D LDY #&CA ;Y=&CA DB2F JSR &E4F1 ;to enter this value in the keyboard buffer Simple isn't it? You can use the routine yourself although further investigation will show that E4F1 is part of an OSbyte call. Remember that the keyboard buffer is buffer 0. E4F1 LDX #&00 ;X=0 keyboard buffer ************************************** * * * OSBYTE 153 Put byte in input * * Buffer checking for ESCAPE * * * ************************************** On entry X = buffer number which is either 0 or 1. If it's 0 then the keyboard buffer is selected. If it's 1 then it is the RS423 buffer. Notice that the JSR to EF41 ensures that ONLY the keyboard buffer can be selected. Once again we are looking at coding economy, in this case with a specific keyboard buffer entry routine. Y contains the character to be written. E4F3 TXA ;A=buffer number E4F4 AND &0245 ;and with RS423 mode (0 treat as keyboard 1 ignore ;Escapes no events no soft keys) E4F7 BNE &E4AF ;so if RS423 buffer AND RS423 in normal mode (1) E4AF ; E4F9 TYA ;else Y=A character to write E4FA EOR &026C ;compare with current escape ASCII code (0=match) E4FD ORA &0275 ;or with current ESCAPE status (0=ESC, 1=ASCII) E500 BNE &E4A8 ;if ASCII or no match E4A8 to enter byte in buffer E502 LDA &0258 ;else get ESCAPE / BREAK action byte E505 ROR ;Rotate to get ESCAPE bit into carry E506 TYA ;get character back in A E507 BCS &E513 ;and if escape disabled exit with carry clear E509 LDY #&06 ;else signal EVENT 6 Escape pressed E50B JSR &E494 ; E50E BCC &E513 ;if event handles ESCAPE then exit with carry clear E510 JSR &E674 ;else set ESCAPE flag E513 CLC ;clear carry E514 RTS ;and exit This routine will normally be accessed by assembly language programmers by OSbyte 138 which calls EF43. BBC 6502 Machine Code Part Eight: Breaker Break ------------------------- One of the 'secret' features of the BBC Micro OS 1.20 when it was arrived was the BREAK intercept. This is a useful method of taking over the machine and is sometimes used by ROM software. There are two entry points, entered with the carry flag reset to 0 and set to 1 respectively. The first call comes before sideways ROM calls. Enter BREAK intercept with Carry Clear DB32 JSR &EAD9 ;check to see if BOOT address is set up if so ;JMP to it The address &287 is written by OSbyte 247 and the jump addresses in &288 and &289 by OSbytes 248 and 249. The machine code for JMP is &4C. EAD9 LDA &0287 ;get BREAK vector code EADC EOR #&4C ;produces 0 if JP (4C) not in &287 EADE BNE &EAF3 ;if not goto EAF3 EAE0 JMP &0287 ;else jump to use BREAK code EAF3 RTS ;Return The RTS at the end of another routine is used because it saves code. Frequently you will find machine code routines where a lot of branches go to a single RTS for just this reason. If you are writing your own code remember that the RTS must be within range of the branch. One of the most common assembler errors is a branch out of range that in turn causes more errors when you add an extra RTS. Obviously at this point the machine could be totally in your control. You can return control to the OS with an RTS or just continue on your merry way. Remember that the sideways ROMs don't have any workspace yet and you can't really run BASIC or any other language as the workspace will not exist. But, assuming that you don't want to do any of this, let's go back to the OS routines after testing for BREAK intercept. DB35 JSR &F140 ;set up cassette options DB38 LDA #&81 ;test for tube to FIFO buffer 1 DB3A STA &FEE0 ; DB3D LDA &FEE0 ; DB40 ROR ;put bit 0 into carry DB41 BCC &DB4D ;if no tube then DB4D DB43 LDX #&FF ;else DB45 JSR &F168 ;issue ROM service call &FF to initialise TUBE system DB48 BNE &DB4D ;if not 0 on exit (tube not initialised) DB4D DB4A DEC &027A ;else set tube flag to show its active Now the Tube is flagged as active, or not as the case may be. We continue next week, with the setup routines for the sideways ROMs. BBC 6502 Machine Code Part Nine: A ROM with a view ----------------------------- Now we nearly have a working system, we are, perhaps, 400 milliseconds into the Power up routine. Now is the time to set up all of those nice sideways ROMs we catalogued earlier. First we set up workspace and hence the value of BASIC's PAGE variable. The call to ROMs is made via F168. This is available to the programmer as OSBYTE 143. A ROM can have a number between 0 and 15 and will have two entry points - a Service entry at &8003 and a Language entry at &8000. If the ROM does not contain language code it will not have a language entry. ROMs are paged into main memory by writing the ROM number to a latch at &FE30. Hardware could be arranged to allow 256 ROMs although the operating system does not support this. The Break Intercept code could be used to make drastic hardware modifications like this. ************************************** * * * OSBYTE 143 * * Pass service commands * * to sideways ROMs * * * ************************************** ;on entry X=command number F168 LDA &F4 ;get current ROM number F16A PHA ;store it F16B TXA ;command in A F16C LDX #&0F ;set X=15 The next bit of code is a countdown loop to send the command code to each enabled ROM in turn. The Map at &2A1 is used to decide which ROMs are active. Note the use of a countdown loop. This gives code economy and explains why the highest ROM number has priority. F16E INC &02A1,X ;read bit 7 on ROM map (no ROM has type 254 &FE) F171 DEC &02A1,X ; F174 BPL &F183 ;if not set (+ve result) F176 STX &F4 ;else store ROM number in &F4 F178 STX &FE30 ;switch in paged ROM F17B JSR &8003 ;and jump to service entry F17E TAX ;on exit put A in X F17F BEQ &F186 ;if 0 (command recognised by ROM) reset ROMs & exit F181 LDX &F4 ;else point to next lower ROM F183 DEX ; F184 BPL &F16E ;and go round loop again F186 PLA ;get back original ROM number F187 STA &F4 ;store it in RAM copy F189 STA &FE30 ;select original page F18C TXA ;put X back in A F18D RTS ;and return Couldn't be easier! So we can now return to the main body of the routine. DB4D LDY #&0E ;set current value of PAGE DB4F LDX #&01 ;issue call to claim absolute workspace DB51 JSR &F168 ;via F168 DB54 LDX #&02 ;send private workspace claim call DB56 JSR &F168 ;via F168 OSHWM is OS High Water Mark. The highest address used by the operating system. DB59 STY &0243 ;set primary OSHWM DB5C STY &0244 ;set current OSHWM DB5F LDX #&FE ;issue call for Tube to explode character set etc. DB61 LDY &027A ;Y=FF if tube present else Y=0 DB64 JSR &F168 ;and make call via F168 We now have the machine set up to enter a language, all the filing systems have been set up and the sideways ROMs activated. Next week we finally start the screen messages. BBC 6502 Machine Code Part Ten: Stringing it along ----------------------------- The next routine shows why the Machine start up message is not always seen on third-party kit. DB67 AND &0267 ;if A=&FE and bit 7 of 0267 is set then continue DB6A BPL &DB87 ;else ignore start up message DB6C LDY #&02 ;output to screen DB6E JSR &DEA9 ;'BBC Computer ' message Looking at the routine in DE9A we find a very useful string printing routine. Remember that Y = 2 on entry. DEA9 LDA #&C3 ;point to start &C300 DEAB STA &FE ;store it DEAD LDA #&00 ;point to lo byte DEAF STA &FD ;store it and start loop with Y=2 DEB1 INY ;print character in string DEB2 LDA (&FD),Y ;pointed to by &FD/E +Y DEB4 JSR OSASCI ;print it expanding Carriage returns DEB7 TAX ;store A in X DEB8 BNE &DEB1 ;and loop again if not =0 DEBA RTS ;else exit Here is the string delimited by BRK. The code for BRK is 00. Y is 3 when the first character is read so its address is &C303. C303 DB 13 ;Carriage Return C304 DB 'BBC Computer ' C311 BRK Notice that the routine uses TAX to set the zero flag which marks the end of the string. This is a useful tip. The next part of the Operating system deals with printing correct messages on the screen. DB71 LDA &028D ;0=warm reset, If a cold reset continue DB74 BEQ &DB82 ; DB76 LDY #&16 ;by checking length of RAM DB78 BIT &028E ; DB7B BMI &DB7F ;and either DB7D LDY #&11 ; DB7F JSR &DEA9 ;finishing message with '16K' or '32K' DB82 LDY #&1B ;and two new lines DB84 JSR &DEA9 ; Notice that Y is used to pick the appropriate message. C312 DB '16K' C315 DB 7 ;Bell C316 BRK C317 DB '32K' C31A DB 7 ;Bell C31B BRK C31C DB 08,0D,0D Notice the BBC Beep at this point indicates that nearly all set up procedures have been finished. The hum is generated by the Sound channel which is reset as part of the start routine. Hence the HUM-BEEP start up. If the machine does not start properly the sound signals give a strong clue to the nature of the problem. Having got this far the OS gives us another chance to take control. Enter BREAK INTERCEPT ROUTINE WITH CARRY SET (call 1) DB87 SEC ; DB88 JSR &EAD9 ;look for break intercept jump ;SEE EARLIER PART Next we set up the keyboard lights DB8B JSR &E9D9 ;set up LEDs in accordance with keyboard status This is another 'undocumented' OSBYTE call. ************************************** * * * OSBYTE &76 (118) * * SET LEDs to Keyboard Status * * * ************************************** ;osbyte entry with carry set E9D9 PHP ;PUSH P E9DA SEI ;DISABLE INTERRUPTS E9DB LDA #&40 ;switch on CAPS and SHIFT lock lights E9DD JSR &E9EA ;via subroutine E9E0 BMI &E9E7 ;if ESCAPE exists (M set) E9E7 E9E2 CLC ;else clear V and C E9E3 CLV ;before calling main keyboard routine to E9E4 JSR &F068 ;switch on lights as required E9E7 PLP ;get back flags E9E8 ROL ;and rotate carry into bit 0 E9E9 RTS ;Return to calling routine ; * Turn on keyboard lights and * Test Escape flag ; E9EA BCC &E9F5 ;if carry clear E9EC LDY #&07 ;switch on shift lock light E9EE STY &FE40 ; E9F1 DEY ;Y=6 E9F2 STY &FE40 ;switch on Caps lock light E9F5 BIT &FF ;set minus flag if bit 7 of &00FF is set indicating E9F7 RTS ;that ESCAPE condition exists, then return The Keyboard routine continues via the KEYV. This is a little long to include here so we'll leave it until a later part. So back to the Start up routine next week with the cassette system. BBC 6502 Machine Code Part Eleven: Language! ---------------------- Having got the keyboard nicely set up the machine proceeds to initialise a filing system and run a !BOOT file if one exists. The start up options are already read from the keyboard links. DB8E PHP ;save flags DB8F PLA ;and get back in A DB90 LSR ;zero bits 4-7 and bits 0-2 bit 4 which was bit 7 DB91 LSR ;may be set DB92 LSR ; DB93 LSR ; DB94 EOR &028F ;EOR with start up options which may or may not DB97 AND #&08 ;invert bit 4 DB99 TAY ;Y=A DB9A LDX #&03 ;make initialisation call if Y=0 on entry DB9C JSR &F168 ;RUN, EXEC or LOAD !BOOT file from a filing system. DB9F BEQ &DBBE ;if a ROM accepts this call then DBBE DBA1 TYA ;else put Y in A DBA2 BNE &DBB8 ;if Y<>0 DBB8 DBA4 LDA #&8D ;else set up standard cassette baud rates DBA6 JSR &F135 ;via &F135 which is OSBYTE 140. DBA9 LDX #&D2 ; DBAB LDY #&EA ; DBAD DEC &0267 ;decrement ignore start up message flag DBB0 JSR OSCLI ;and execute /!BOOT DBB3 INC &0267 ;restore start up message flag DBB6 BNE &DBBE ;if not zero then DBBE DBB8 LDA #&00 ;else A=0 DBBA TAX ;X=0 DBBB JSR &F137 ;set tape speed via OSBYTE 140. We now have an active filing system. The next job is to preserve the current language on soft RESET. DBBE LDA &028D ;get last RESET Type DBC1 BNE &DBC8 ;if not soft reset DBC8 DBC3 LDX &028C ;else get current language ROM address DBC6 BPL &DBE6 ;if +ve (language available) then skip search ;routine For a cold break we search for the language with the highest priority. DBC8 LDX #&0F ;set pointer to highest available ROM DBCA LDA &02A1,X ;get ROM type from map DBCD ROL ;put hi-bit into carry, bit 6 into bit 7 DBCE BMI &DBE6 ;if bit 7 set then ROM has a language entry so DBE6 DBD0 DEX ;else search for language until X=&ff Check for Tube if no language found. DBD1 BPL &DBCA ;check if tube present DBD3 LDA #&00 ;if bit 7 of tube flag is set BMI succeeds DBD5 BIT &027A ;and TUBE is connected else DBD8 BMI &DC08 ;make error No language error DBDA BRK ; DBDB DB &F9 ;error number DBDC DB 'Language?' ;message DBE5 BRK ; This might seem odd as BRK is handled by the current language BRK handler,but we don't have a language! We need to investigate further in another part. DBE6 CLC ; OSBYTE 142 enter Language ROM at &8000 X=ROM number. Carry is set if this is an OSBYTE call and clear if this is an initialisation routine. DBE7 PHP ;save flags DBE8 STX &028C ;put X in current ROM page DBEB JSR &DC16 ;select that ROM DBEE LDA #&80 ;A=128 DBF0 LDY #&08 ;Y=8 DBF2 JSR &DEAB ;display text string held in ROM at &8008,Y DBF5 STY &FD ;save Y on exit (end of language string) DBF7 JSR OSNEWL ;two line feeds DBFA JSR OSNEWL ;are output DBFD PLP ;then get back flags DBFE LDA #&01 ;A=1 required for language entry DC00 BIT &027A ;check if tube exists DC03 BMI &DC08 ;and goto DC08 if it does DC05 JMP &8000 ;else enter language at &8000 TUBE FOUND enter tube software DC08 JMP &0400 ;enter tube environment The Tube initialisation would have read the language across to the TUBE usually but it could be loaded by a !BOOT file from the filing system initialisation. The operating system now stops general control of the system and hands this to the language which looks after command lines etc. The OS however still handles the screen, keyboard and much else. Notice how every possible eventuality was taken into account during the initialisation routine. This is one of the things that made the Beeb a very powerful machine. Next week we'll have a look at the Interrupt code. BBC 6502 Machine Code Part Twelve: Pardon me! ----------------------- We finished the last part at the point where the operating systems power up routine handed over control to the language. We'll write our own language later in the series but for now let's dive into another entry point. When the processor's RQ pin (4) goeslow (0V) the processor finishes off the current instruction and then goes off to run some microcode of its own. This checks that the RDY (2) pin is high and that the interrupt flag in the status register is 0 (not set). If it is set the interrupt is ignored and the processor goes to the next instruction. This continues when the IRQ pin is low. If the flag is clear then the processor stores the program counter and status register on the stack and sets the interrupt flag. The 6502 then gets the address stored in &FFFE and &FFFF and executes this instruction next. If a BRK instruction is found in executing code then the processor performs exactly the same actions except that it does not check the status register for the interrupt flag, it does set a flag in the status register, the BRK flag. The main entry point for IRQ (and BRK) for OS 1.20 is &DC51. MAIN IRQ Entry point ;ON ENTRY STACK contains STATUS REGISTER,PCH,PCL DC1C STA &FC ;save A DC1E PLA ;get back status (flags) DC1F PHA ;and save again DC20 AND #&10 ;check if BRK flag set DC22 BNE &DC27 ;if so goto DC27 DC24 JMP (&0204) ;else JUMP through IRQ1V That's pretty straightforward so far. As you can see IRQ1V allows you to put your own hardware at a higher priority than anything else in the machine. You can also write your own hardware interrupt handler if you wish. This is the flexibility that made the BBC machine so remarkably successful among knowledgeable users. Let's look at the BRK handler now. * BRK handling routine * DC27 TXA ;save X on stack DC28 PHA ; DC29 TSX ;get status pointer DC2A LDA &0103,X ;get Program Counter low byte DC2D CLD ; DC2E SEC ;set carry DC2F SBC #&01 ;subtract 2 (1+carry) DC31 STA &FD ;and store it in &FD DC33 LDA &0104,X ;get hi byte DC36 SBC #&00 ;subtract 1 if necessary DC38 STA &FE ;and store in &FE DC3A LDA &F4 ;get currently active ROM DC3C STA &024A ;and store it in &24A DC3F STX &F0 ;store stack pointer in &F0 DC41 LDX #&06 ;and issue ROM service call 6 DC43 JSR &F168 ;(User BRK) to ROMs ;now &FD/E points to byte after BRK ;ROMS may use BRK for their own purposes ;and many do! It's interesting to see what happens with the ROM handler. This is also an entry point for OSBYTE 143 so you can use this in your own code. * OSBYTE 143 * *Pass service commands to sideways ROMs * ;on entry X=command number F168 LDA &F4 ;get current ROM number F16A PHA ;store it F16B TXA ;command in A F16C LDX #&0F ;set X=15 ;send commands loop F16E INC &02A1,X ;read bit 7 on ROM map (no ROM has ;type 2) 4 &FE) F171 DEC &02A1,X ; F174 BPL &F183 ;if not set (+ve result) F176 STX &F4 ;else store ROM number in &F4 F178 STX &FE30 ;switch in paged ROM F17B JSR &8003 ;and jump to service entry F17E TAX ;on exit put A in X F17F BEQ &F186 ;if 0 (command recognised by ROM) ;reset ROMs & exit F181 LDX &F4 ;else point to next lower ROM F183 DEX ; F184 BPL &F16E ;and go round loop again F186 PLA ;get back original ROM number F187 STA &F4 ;store it in RAM copy F189 STA &FE30 ;select original page F18C TXA ;put X back in A F18D RTS ;and return Useful little routine that. So back to the BRK handler. DC46 LDX &028C ;get current language DC49 JSR &DC16 ;and activate it DC4C PLA ;get back original value of X DC4D TAX ; DC4E LDA &FC ;get back original value of A DC50 CLI ;allow interrupts DC51 JMP (&0202) ;and JUMP via BRKV (normally into current language) Next week we'll carry on by taking a look at the BRK handler. BBC 6502 Machine Code Part Thirteen: Give us a BRK ---------------------------- BRK is usually handled by the default language (or by a Sideways ROM). However, it may be that you are running a machine code program before a current language is set up or perhaps your language doesn't handle BRK (it should but you never know). That's when a default BRK handler takes over. * DEFAULT BRK HANDLER * DC54 LDY #&00 ;Y=0 to point to byte after BRK DC56 JSR &DEB1 ;print message Let's have a look at the print routine. Remember that the error- handling layout is: BRK Error Number (1 byte) Message BRK Y plus the address in &FD &FE points to the error message on entry. DEB1 INY ;point to first ;character in string DEB2 LDA (&FD),Y DEB4 JSR OSASCI ;print it ;expanding ;Carriage ;returns DEB7 TAX ;store A in X to change flags DEB8 BNE &DEB1 ;and loop again if not =0 DEBA RTS ;else exit A standard print routine, nothing out of the ordinary but nice and compact. You can use this in your own print routines by changing the zero page values. Back to the default BRK handler and an interesting bit of code. DC59 LDA &0267 ;if BIT 0 set and DISK EXEC error DC5C ROR ;occurs DC5D BCS &DC5D ;hang up machine! Nasty! But the machine has to be in a pretty unusual configuration for this to happen. Mind you, setting 0267 then doing a JSR to DC59 would confuse the average user. DC5F JSR OSNEWL ;else print two newlines DC62 JSR OSNEWL ; DC65 JMP &DBB8 ;and set tape speed before entering the current ;language DBB8 LDA #&00 ;else A=0 DBBA TAX ;X=0 DBBB JSR &F137 ;set tape speed via OSBYTE 141. There's the end of the BRK handling code. As I said before this is generally handled by the default language but you can arrange for your own code or a Sideways ROM to handle it. Next week we'll return to the interrupt system with a look at the default entry point for IRQ1. BBC 6502 Machine Code Part Fourteen: The story so far... ---------------------------------- We left the interrupt-handling routine just after it had gone off to the IRQ1V vector. If you don't change the vector the code continues from DC93. One very important thing to remember about an interrupt-driven machine like the BBC is that the interrupt flag is not set for too long. If it is the machine could crash. This means that interrupt routines are short and snappy. * Main IRQ Handling routines, default IRQIV destination * DC93 CLD ;clear decimal flag DC94 LDA &FC ;get original value of A DC96 PHA ;save it DC97 TXA ;save X DC98 PHA ; DC99 TYA ;and Y DC9A PHA ;on the stack ;note the pre-CMOS code! DC9B LDA #&DE ;A=&DE DC9D PHA ;store it DC9E LDA #&81 ;save &81 DCA0 PHA ;store it (a RTS will now jump to DE82) This is quite a useful technique as we will see later. If we now use JMP to go to an OS routine we can ensure that the routine, which ends with an RTS, causes execution to go to a specified point. This saves a lot of code as it can be arranged that the first device found that called the interrupt will be the only one handled. This, in turn, saves time! We now poll the hardware looking for who caused it. The first routine deals with the serial/tape system. DCA1 CLV ;clear V flag DCA2 LDA &FE08 ;get value of status register of ACIA DCA5 BVS &DCA9 ;if this was source then DCA9 to process DCA7 BPL &DD06 ;else if no interrupt requested DD06 DCA9 LDX &EA ;read RS423 timeout counter DCAB DEX ;decrement it DCAC BMI &DCDE ;and if <0 DCDE DCAE BVS &DCDD ;else if >&40 DCDD (RTS to DE82) DCB0 JMP &F588 ;else read ACIA via F588 ;RTS ends routine!! DCB3 LDY &FE09 ;read ACIA data DCB6 ROL ; DCB7 ASL ; DCB8 TAX ;X=A DCB9 TYA ;A=Y DCBA LDY #&07 ;Y=07 DCBC JMP &E494 ;check and service EVENT 7 RS423 error DCBF LDX #&02 ;read RS423 output buffer DCC1 JSR &E460 ; DCC4 BCC &DCD6 ;if C=0 buffer is not empty goto DCD6 DCC6 LDA &0285 ;else read printer destination DCC9 CMP #&02 ;is it serial printer?? DCCB BNE &DC68 ;if not DC68 DCCD INX ;else X=3 DCCE JSR &E460 ;read printer buffer DCD1 ROR &02D2 ;rotate to pass carry into bit 7 DCD4 BMI &DC68 ;if set then DC68 DCD6 STA &FE09 ;pass either printer or RS423 data to ACIA DCD9 LDA #&E7 ;set timeout counter to stored value DCDB STA &EA ; DCDD RTS ;and exit (to DE82) ;A contains ACIA status DCDE AND &0278 ;AND with ACIA bit mask (normally FF) DCE1 LSR ;rotate right to put bit 0 in carry DCE2 BCC &DCEB ;if carry clear receive register not full so DCEB DCE4 BVS &DCEB ;if V is set then DCEB DCE6 LDY &0250 ;else Y=ACIA control setting DCE9 BMI &DC7D ;if bit 7 set receive interrupt is enabled so DC7D DCEB LSR ;put BIT 2 of ACIA status into DCEC ROR ;carry if set then Data Carrier Detected applies DCED BCS &DCB3 ;jump to DCB3 DCEF BMI &DCBF ;if original bit 1 is set TDR is empty so DCBF DCF1 BVS &DCDD ;if V is set then exit to DE82 DCF3 LDX #&05 ;X=5 DCF5 JSR &F168 ;issue ROM call 5 'unrecognised ;interrupt' We've seen this ROM service routine call before. DCF8 BEQ &DCDD ;if a ROM recognises it then exit to DE82 DCFA PLA ;otherwise get back DE82 address from stack DCFB PLA ; DCFC PLA ;and get back X, Y and A DCFD TAY ; DCFE PLA ; DCFF TAX ; DD00 PLA ; DD01 STA &FC ;&FC=A DD03 JMP (&0206) ;and offer to the user via IRQ2V That was a little convoluted, to say the least. Next week we look at how the VIAs are dealt with. BBC 6502 Machine Code Part Fifteen: Hardware VIA interrupts ------------------------------------- After deciding that it wasn't the ACIA that caused the interrupt, the VIAs are the next port of inquisition. * VIA INTERRUPTS ROUTINES * DD06 LDA &FE4D ;read system VIA interrupt flag register DD09 BPL &DD47 ;if bit 7=0 the VIA has not caused interrupt goto DD47 DD0B AND &0279 ;mask with VIA bit mask DD0E AND &FE4E ;and interrupt enable register DD11 ROR ;rotate right twice to ;check for IRQ 1 (frame sync) DD12 ROR ; DD13 BCC &DD69 ;if carry clear then no IRQ 1, else IRQ 1 means ;interrupt request 1. This is different from the ;vector IRQ1. DD15 DEC &0240 ;decrement vertical sync counter DD18 LDA &EA ;A=RS423 Timeout counter DD1A BPL &DD1E ;if +ve then DD1E DD1C INC &EA ;else increment it DD1E LDA &0251 ;load flash character counter DD21 BEQ &DD3D ;if 0 then flash system is not in use, ignore it DD23 DEC &0251 ;else decrement counter DD26 BNE &DD3D ;and if not 0 go on past reset routine This routine resets the flashing character system. DD28 LDX &0252 ;get mark period count in X DD2B LDA &0248 ;current VIDEO ULA control setting in A DD2E LSR ;shift bit 0 into C to ;check if first colour DD2F BCC &DD34 ;is effective if so C=0. Jump to DD34 DD31 LDX &0253 ;else get space period count in X DD34 ROL ;restore bit DD35 EOR #&01 ;and invert it DD37 JSR &EA00 ;then change colour DD3A STX &0251 ;&0251=X resetting the counter DD3D LDY #&04 ;Y=4 and call E494 to check and implement vertical DD3F JSR &E494 ;sync event (4) if necessary DD42 LDA #&02 ;A=2 DD44 JMP &DE6E ;clear interrupt 1 and exit Remember the RTS routine last time? * PRINTER INTERRUPT USER VIA 1 * DD47 LDA &FE6D ;Check USER VIA interrupt flags register DD4A BPL &DCF3 ;if +ve USER VIA did not call interrupt DD4C AND &0277 ;else check for USER IRQ 1 printer interrupt. DD4F AND &FE6E ; DD52 ROR ; DD53 ROR ; DD54 BCC &DCF3 ;if bit 1=0 then no ;interrupt 1 so DCF3 DD56 LDY &0285 ;else get printer type DD59 DEY ;decrement DD5A BNE &DCF3 ;if not parallel then :CF3 DD5C LDA #&02 ;reset interrupt 1 flag DD5E STA &FE6D ; DD61 STA &FE6E ;disable interrupt 1 DD64 LDX #&03 ;and output data to parallel printer DD66 JMP &E13A ;and exit via RTS * SYSTEM INTERRUPT 5 Speech * DD69 ROL ;get bit 5 into bit 7 DD6A ROL ; DD6B ROL ; DD6C ROL ; DD6D BPL &DDCA ;if not set this is not ;a speech interrupt so DDCA DD6F LDA #&20 ; DD71 LDX #&00 ; DD73 STA &FE4D ; DD76 STX &FE49 ;and zero high byte of Timer t2 DD79 LDX #&08 ;&FB=8 DD7B STX &FB ; DD7D JSR &E45B ;and examine buffer 8 DD80 ROR &02D7 ;shift carry into bit 7 DD83 BMI &DDC9 ;and if set buffer is empty so exit DD85 TAY ;else Y=A DD86 BEQ &DD8D ; DD88 JSR &EE6D ;control speech chip DD8B BMI &DDC9 ;if negative exit DD8D JSR &E460 ;else get a byte from buffer DD90 STA &F5 ;store it to indicate speech or file ROM DD92 JSR &E460 ;get another byte DD95 STA &F7 ;store it DD97 JSR &E460 ;and another DD9A STA &F6 ;giving address to be accessed in paged ROM DD9C LDY &F5 ;Y=&F5 DD9E BEQ &DDBB ;and if =0 then DDBB DDA0 BPL &DDB8 ;else if +ve DDB8 DDA2 BIT &F5 ;if bit 6 of F5 =1 (&F5)>&40 DDA4 BVS &DDAB ;then DDAB DDA6 JSR &EEBB ;else continue for more speech processing DDA9 BVC &DDB2 ;if bit 6 clear then DDB2 DDAB ASL &F6 ;else double address in &F6/7 DDAD ROL &F7 ; DDAF JSR &EE3B ;and call EE3B DDB2 LDY &0261 ;get speech enable/disable flag into Y DDB5 JMP &EE7F ;and JMP to EE7F DDB8 JSR &EE7F ;Call EE7F DDBB LDY &F6 ;get address pointer in Y DDBD JSR &EE7F ; DDC0 LDY &F7 ;get address pointer high in Y DDC2 JSR &EE7F ; DDC5 LSR &FB ; DDC7 BNE &DD7D ; DDC9 RTS ;and exit Next week we continue with a look at the remaining System Interrupts. BBC 6502 Machine Code Part Sixteen: Timers and Keyboard Interrupts -------------------------------------------- The last part showed how the BBC Micro handles some of the system interrupt calls. Most of these are pretty routine so we won't continue with an interminable list. The next interesting routines concern how the timers and keyboard interrupts are handled. * SYSTEM INTERRUPT 6 10mS Clock * DDCA BCC &DE47 ;bit 6 is in carry so if clear there is no 6 so go ;on to DE47 DDCC LDA #&40 ;Clear interrupt 6 DDCE STA &FE4D ; This is the start of the update timers routine, This is interesting because of the way that the timer information is stored. It's very clever. There are two timer stores, &292-6 and &297-B. These are updated by adding 1 to the current timer and storing the result in the other, the direction of transfer being changed each time of update. This ensures that at least one timer is valid at any call as the current timer only is read. Other methods would cause inaccuracies if a timer was read while being updated. DDD1 LDA &0283 ;get current system clock store pointer (5,or 10) DDD4 TAX ;put A in X DDD5 EOR #&0F ;and invert lo nybble (5becomes 10 and vv) DDD7 PHA ;store A DDD8 TAY ;put A in Y. Carry is always set at this point DDD9 LDA &0291,X ;get timer value DDDC ADC #&00 ;update it DDDE STA &0291,Y ;store result in alternate DDE1 DEX ;decrement X DDE2 BEQ &DDE7 ;if 0 exit DDE4 DEY ;else decrement Y DDE5 BNE &DDD9 ;and go back and do next byte DDE7 PLA ;get back A DDE8 STA &0283 ;and store back in clock pointer (ie. inverse ;previous contents) DDEB LDX #&05 ;set loop pointer for countdown timer DDED INC &029B,X ;increment byte and DDF0 BNE &DDFA ;if not 0 then DDFA DDF2 DEX ;else decrement pointer DDF3 BNE &DDED ;and if not 0 do it again DDF5 LDY #&05 ;process EVENT 5 interrupt timer DDF7 JSR &E494 ; DDFA LDA &02B1 ;get byte of inkey countdown timer DDFD BNE &DE07 ;if not 0 then DE07 DDFF LDA &02B2 ;else get next byte DE02 BEQ &DE0A ;if 0 DE0A DE04 DEC &02B2 ;decrement 2B2 DE07 DEC &02B1 ;and 2B1 DE0A BIT &02CE ;read bit 7 of envelope processing byte DE0D BPL &DE1A ;if 0 then DE1A DE0F INC &02CE ;else increment to 0 DE12 CLI ;allow interrupts DE13 JSR &EB47 ;and do routine sound processes DE16 SEI ;bar interrupts DE17 DEC &02CE ;DEC envelope processing byte back to 0 DE1A BIT &02D7 ;read speech buffer busy flag DE1D BMI &DE2B ;if set speech buffer is empty, skip routine DE1F JSR &EE6D ;update speech system variables DE22 EOR #&A0 ; DE24 CMP #&60 ; DE26 BCC &DE2B ;if result >=&60 DE2B DE28 JSR &DD79 ;else more speech work DE2B BIT &D9B7 ;set V and C DE2E JSR &DCA2 ;check if ACIA needs attention DE31 LDA &EC ;check if key has been pressed DE33 ORA &ED ; DE35 AND &0242 ;(this is 0 if keyboard is to be ignored, else ;&FF) DE38 BEQ &DE3E ;if 0 ignore keyboard DE3A SEC ;else set carry DE3B JSR &F065 ;and call keyboard DE3E JSR &E19B ;check for data in use defined printer channel DE41 BIT &FEC0 ;if ADC bit 6 is set ADC is not busy DE44 BVS &DE4A ;so DE4A DE46 RTS ;else return * SYSTEM INTERRUPT 4 ADC end of conversion * DE47 ROL ;put original bit 4 from FE4D into bit 7 of A DE48 BPL &DE72 ;if not set DE72 DE4A LDX &024C ;else get current ADC channel DE4D BEQ &DE6C ;if 0 DE6C DE4F LDA &FEC2 ;read low data byte DE52 STA &02B5,X ;store it in &2B6,7,8 or 9 DE55 LDA &FEC1 ;get high data byte DE58 STA &02B9,X ;and store it in hi byte DE5B STX &02BE ;store in Analogue system flag marking last channel DE5E LDY #&03 ;handle event 3 conversion complete DE60 JSR &E494 ; DE63 DEX ;decrement X DE64 BNE &DE69 ;if X=0 DE66 LDX &024D ;get highest ADC channel present DE69 JSR &DE8F ;and start new conversion DE6C LDA #&10 ;reset interrupt 4 DE6E STA &FE4D ; DE71 RTS ;and return * SYSTEM INTERRUPT 0 Keyboard * DE72 ROL ;get original bit 0 in bit 7 position DE73 ROL ; DE74 ROL ; DE75 ROL ; DE76 BPL &DE7F ;if bit 7 clear not a keyboard interrupt DE78 JSR &F065 ;else scan keyboard DE7B LDA #&01 ;A=1 DE7D BNE &DE6E ;and off to reset interrupt and exit DE7F JMP &DCF3 ;and again a subroutine to exit. Now we come to the point you've all been waiting for. This mystery RTSreturns all subroutines to &DE82. ************** exit routine DE82 PLA ;restore registers DE83 TAY ; DE84 PLA ; DE85 TAX ; DE86 PLA ; DE87 STA &FC ;store A * IRQ2V default entry * DE89 LDA &FC ;get back original value of A DE8B RTI ;and return to calling routine. NEXT WEEK: OSBYTE entry. BBC 6502 Machine Code Part Seventeen: The BBC Operating System ---------------------------------------- We've been examining the BBC operating system in some detail over the last few weeks. Unfortunately the demise of Micronet means that we cannot finish completely, as we hoped. So we've put together the next twenty weeks' articles in the form of a completely commented disassembly of OS 1.20. This is an excellent example of BBC programming and is full of tips. Just to remind you of the main points of the software. Entry points are pointed to by a jump table in the last six bytes of the ROM. The font characters are located from &C000 to &C2FF. OK, so here it is all commented and ready for you to peruse. Ed says: I have uploaded the series of disassembly articles as ten short TSW files. Look on Micronet on 700100239 (before it's too late!) ÿ *********** THE END **********