Fusion_C and HTIMI

Hi! You can set up your own interrupt routine like this, with or without Fusion-C :
(it's just an example, the program displays the number of loop cycles between two interrupts and stops when you press space)

#include < stdio.h >
#include < stdlib.h >
#include "fusion-c/header/msx_fusion.h"

// io ports for vdp
__sfr __at (0x98) VDP_port1;
__sfr __at (0x99) VDP_port2;

volatile char vdp_status;
volatile int  sync_flag;
volatile int  cpt;

void interrupt_routine () __critical __interrupt(0)
__preserves_regs(a,b,c,d,e,h,l,iyl,iyh) {

// read the vdp status. Mandatory to have a new interrupt!
  vdp_status = VDP_port2;

  cpt++;

  sync_flag=1; // set the synchronization flag to 1

}

void main (void)
{
  unsigned int top=1;
  unsigned int im1;
  unsigned int key=0;
  unsigned int nbb=0;
// save MSX system original interrupt address
  im1=Peekw(57);

//  printf("it=%x\n\r",im1); // causes the interrupt to skip the while statement, and then ends program!

// interrupt setup
  sync_flag=0;
  __critical { *((unsigned int*)57)=(unsigned int)interrupt_routine; }

  cpt=0;

/***** main cycle *****/
  while (top==1) {
    nbb++;
    key=Inkey();
    if (key==32) {top=2;}
    if (cpt==10) {cpt=0;printf("%d ",nbb);nbb=0;}

// interruption detection
// if sync_flag = 0 -> no interrupt occurred since the beginning of main cycle
// if sync_flag = 1 -> 1 or more interrupts have already occurred
    if (!sync_flag) {
      sync_flag=0;
    }

  }

// put back the original interrupt
  Pokew(57,im1); // address, data

  printf("Back to MSX-DOS\n\r");

  Exit(0);
}

You're right Grauw, I'm too focused on games for ROM , the development for MSX-DOS requires to respect the operating system.

Maybe someone has an example to give ?
Among Fusion-C examples there is :

// Interrupt functions Test
// Fusion-c 1.1

#include "fusion-c/header/msx_fusion.h"
#include 



static unsigned int count = 0;

/* --------------------------------------------------------- */
static char my_interrupt( void ) {

  if( IsVsync() == 0 ) return 0;

  count++;
  return 1;
}

/* --------------------------------------------------------- */
int main( void ) {
  unsigned int prev_count;
  InitInterruptHandler();

  SetInterruptHandler( my_interrupt );

  prev_count = 0;
  while( prev_count < 600 ) {

    DisableInterrupt();
    prev_count = count;
    EnableInterrupt();

    printf( "%d\n\r", prev_count );
  }
  EndInterruptHandler();
  return 0;
}

. @grauw:
About the use of CALLF I see it can be used to make a interslot call. However how I can use it in a C environment under msx dos 1 to hook HTIMI is unclear to me. What value I need to poke in the hook for the slot id parameter?
When I install my interrupt hook I m working on a standard msx dos configuration where all 64k are ram.
While I am able to poke into hook area the 0xc3 lowbyte highbyte sequence of my int hook routine I almost am sure that this will not work when the hook gets called because of paging issues...

Almost forgot... Here is my interrupt.s

There may still be room for improvement but for normal use, it's better than the old one in Fusion-C.

; ___________________________________________________________
;/               __           _                              \
;|              / _|         (_)                             |
;|             | |_ _   _ ___ _  ___  _ __                   |
;|             |  _| | | / __| |/ _ \| '_ \                  |
;|             | | | |_| \__ \ | (_) | | | |                 |
;|             |_|  \__,_|___/_|\___/|_| |_| *               |
;|                                                           |
;|               The MSX C Library for SDCC                  |
;|                     V1.1   -  05-2019                     |
;|                                                           |
;|                Eric Boez &  Fernando Garcia               |
;|                                                           |
;|               A S M  S O U R C E   C O D E                |
;|                                                           |
;|                                                           |
;\___________________________________________________________/
;
;
;	Interrupt functions
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;	2006/11/25	t.hara														;;
;;	2019/09/02	Pasi Kettunen												;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
;

 .area _CODE
	.globl	_SetInterruptHandler
	.globl	_EndInterruptHandler
  
; ---------------------------------------------------------
reset_vect	= 0x0000
bdos		= 0x0005
H_TIMI		= 0xFD9F
INTHANDLER	= 0xF975 ; Repurposing BASIC PLAY commands Voice A queue

; ---------------------------------------------------------
;	void SetInterruptHandler( void (*p_handler)( void ) )
; ---------------------------------------------------------
_SetInterruptHandler::

	di
	pop		af
	pop		hl
	push	hl
	push	af
	ld		a,h
	or		l
	jr		z,isnull
	ld		(user_interrupt + 2),hl

	ld		hl,(savedhook + 1)
	ld		a,h
	or		l
	jr		nz,already_set
	ld		hl, #H_TIMI
	ld		de, #savedhook
	ld		bc, #5
	ldir
already_set:
	ld		hl, #inthandler_start
	ld		de, #INTHANDLER
	ld		bc, #inthandler_end - inthandler_start
	ldir
	
	ld		a, #0xc3				;	jp intr_handler
	ld		(H_TIMI), a
	ld		hl,#INTHANDLER
	ld		(H_TIMI+1), hl
isnull:
	ei
	ret

; ---------------------------------------------------------
;	void EndInterruptHandler(void)
; ---------------------------------------------------------
_EndInterruptHandler::
	ld		hl,(savedhook + 1)
	ld		a,h
	or		l
	ret		z

	di
	ld		hl, #savedhook
	ld		de, #H_TIMI
	ld		bc, #5
	ldir
	ld		hl,#0
	ld		(savedhook + 1), hl
	ld		a,#0xF9	; RET
	ld		(savedhook),a
	ei
	ret

; ---------------------------------------------------------
;	intr_handler
; ---------------------------------------------------------

inthandler_start:
	push	af
    push	ix
    push	iy
user_interrupt:
    ld		ix,#0
    ld		iy,(0xF341)      ; main ram slotaddress
    call	0x001c           ; interslotcall
	pop		iy
	pop		ix
pass:
	pop		af

savedhook:
	ret
	.dw		0
	.dw		0

inthandler_end:

Here is how to use it:

  SetInterruptHandler( my_int_function );
...

//when done
  EndInterruptHandler();

I think there might come problems if using disk-rom etc when the handler is active, depending on where in ram "my_int_function" is located. Haven't tested that yet. But most BIOS usage, like KB / joystick reading etc should be fine.

Interrupt function MUST not be in page 0 (0x00000-0x3fff) if it is a MSX-DOS target, otherwise your hook will call bios if interrupt comes when your code or previous interrupt handler paged bios in page 0,not sure for other targets.