sigproc.s

测量脉搏的源码 Cypress公司使用 CY27443 完成相关的功能

	.module sigproc.c
	.area data(ram, con, rel)
_adc_max_prev:
	.blkb 2
	.area idata
	.word 0
	.area data(ram, con, rel)
	.dbfile ./sigproc.c
	.dbsym s adc_max_prev _adc_max_prev I
_peak_delta:
	.blkb 2
	.area idata
	.word 0
	.area data(ram, con, rel)
	.dbfile ./sigproc.c
	.dbsym s peak_delta _peak_delta i
	.area lit(rom, con, rel)
_gain_table:
	.byte 1,2
	.byte 3,4
	.byte 5,8
	.byte 12,16
	.dbsym s gain_table _gain_table A[8:8]c
	.area data(ram, con, rel)
	.dbfile ./sigproc.c
_gain_level:
	.blkb 1
	.area idata
	.byte 0
	.area data(ram, con, rel)
	.dbfile ./sigproc.c
	.dbsym s gain_level _gain_level c
L3:
	.blkb 2
	.area idata
	.word 0
	.area data(ram, con, rel)
	.dbfile ./sigproc.c
L4:
	.blkb 2
	.area idata
	.word 0
	.area data(ram, con, rel)
	.dbfile ./sigproc.c
L5:
	.blkb 1
	.area idata
	.byte 0
	.area data(ram, con, rel)
	.dbfile ./sigproc.c
	.area bss(ram, con, rel)
	.dbfile ./sigproc.c
L6:
	.blkb 2
L7:
	.blkb 2
	.area data(ram, con, rel)
	.dbfile ./sigproc.c
L8:
	.blkb 1
	.area idata
	.byte 0
	.area data(ram, con, rel)
	.dbfile ./sigproc.c
L9:
	.blkb 2
	.area idata
	.word 300
	.area data(ram, con, rel)
	.dbfile ./sigproc.c
L10:
	.blkb 2
	.area idata
	.word 0
	.area data(ram, con, rel)
	.dbfile ./sigproc.c
L11:
	.blkb 2
	.area idata
	.word 0
	.area data(ram, con, rel)
	.dbfile ./sigproc.c
L12:
	.blkb 2
	.area idata
	.word 0
	.area data(ram, con, rel)
	.dbfile ./sigproc.c
L13:
	.blkb 2
	.area idata
	.word 0
	.area data(ram, con, rel)
	.dbfile ./sigproc.c
	.area bss(ram, con, rel)
	.dbfile ./sigproc.c
L14:
	.blkb 2
	.area text(rom, con, rel)
	.dbfile ./sigproc.c
	.dbfunc e adc_sig_proc _adc_sig_proc fV
	.dbsym s peak_ind_old L14 i
	.dbsym s peak_ind L13 i
	.dbsym s int_cnt L12 i
	.dbsym s peak_max L11 I
	.dbsym s adc_max L10 I
	.dbsym s th L9 I
	.dbsym s ran_cnt L8 c
	.dbsym s temp L7 I
	.dbsym s hpf_data L6 I
	.dbsym s loop L5 c
	.dbsym s lpf2 L4 I
	.dbsym s lpf1 L3 I
_adc_sig_proc::
	.dbline -1
	push A
	mov A,[__r0]
	push A
	mov A,[__r1]
	push A
	mov A,[__r2]
	push A
	mov A,[__r3]
	push A
	mov A,[__rX]
	push A
	mov A,[__rY]
	push A
	mov A,[__rZ]
	push A
	push X
	mov X,SP
	add SP,2
	.dbline 38
; 
; #include "PSoCApi.h"
; #include <m8c.h>
; #include "globdefs.h"
; #include "utils.h"
; 
; #define TH_DELTA 200
; 
; #define LPF_SHIFT 2
; 
; extern INT ADC_iResult;
; 
; #define HPF_BUFFER_LEN 7
; static INT hpf_buffer[HPF_BUFFER_LEN];
; 
; static INT adc_max_prev = 0;
; static PULSE_INTERVAL_TYPE peak_delta = 0; 
; 
; #define RANGE_POINTS 200
; #define TH_MIN 300
; #define TH_MAX 1500
; #define TH_FILTER_SHIFT 1
; 
; #define AGC_DOWN_THESHOLD 10000
; #define AGC_UP_THESHOLD  4000
; #define GAIN_LEVELS 8
; #define AGC_GAIN_HIGH 6
; #define AGC_GAIN_LOW 0  
; static const BYTE gain_table[GAIN_LEVELS] = {1, 2, 3, 4, 5, 8, 12, 16};
; static BYTE gain_level = 0;
; 
; #if DEBUG
; static INT debug = 0;
; #endif
; 
; #pragma interrupt_handler adc_sig_proc;
; void adc_sig_proc(void)
; {
	.dbline 51
;   static INT lpf1 = 0, lpf2 = 0;
;   static BYTE loop = 0;
;   static INT hpf_data;
;   static INT temp;
;   
;   static BYTE ran_cnt = 0;
;   static INT th = TH_MIN, adc_max = 0;
;   
;   static INT peak_max = 0;
;   static PULSE_INTERVAL_TYPE int_cnt = 0, peak_ind = 0, peak_ind_old;
;   
;           
;   lpf1 -= (lpf1 >> LPF_SHIFT) - (ADC_iResult - ADC_SHIFT);
	mov [__r1],[L3+1]
	mov [__r0],[L3]
	asr [__r0]
	rrc [__r1]
	asr [__r0]
	rrc [__r1]
	mov A,[_ADC_iResult+1]
	sub A,-60
	mov [__r3],A
	mov A,[_ADC_iResult]
	sbb A,9
	mov [__r2],A
	mov A,[__r3]
	sub [__r1],A
	mov A,[__r2]
	sbb [__r0],A
	mov A,[__r1]
	sub [L3+1],A
	mov A,[__r0]
	sbb [L3],A
	.dbline 52
;   lpf2 += (lpf1 >> 1) - (lpf2 >> LPF_SHIFT);
	mov [__r1],[L3+1]
	mov [__r0],[L3]
	asr [__r0]
	rrc [__r1]
	mov [__r3],[L4+1]
	mov [__r2],[L4]
	asr [__r2]
	rrc [__r3]
	asr [__r2]
	rrc [__r3]
	mov A,[__r3]
	sub [__r1],A
	mov A,[__r2]
	sbb [__r0],A
	mov A,[__r1]
	add [L4+1],A
	mov A,[__r0]
	adc [L4],A
	.dbline 54
;   
;   M8C_EnableGInt; 
		or  F, 01h

	.dbline 56
;   
;   if ((lpf2 > AGC_DOWN_THESHOLD) && (gain_level > AGC_GAIN_LOW)) 
	mov A,[L4]
	xor A,-128
	mov [__rY],A
	mov A,39
	xor A,-128
	mov [__rZ],A
	mov [__rX],0
	mov A,[L4+1]
	sub A,16
	or [__rX],A
	mov A,[__rY]
	sbb A,[__rZ]
	or [__rX],A
	jc L15
	mov A,[__rX]
	jz L15
X0:
	cmp [_gain_level],0
	jc L15
	jz L15
X1:
	.dbline 57
;     In_BPF_FILT_C1_REG = (In_BPF_FILT_C1_REG & 0xE0) | gain_table[--gain_level]; 
	mov A,[_gain_level]
	sub A,1
	mov [__r0],A
	mov [_gain_level],A
	mov A,REG[-128]
	mov [__r2],A
	and [__r2],-32
	mov [__r1],[__r0]
	mov [__r0],0
	add [__r1],<_gain_table
	adc [__r0],>_gain_table
	mov A,[__r0]
	push X
	mov X,[__r1]
	romx
	pop X
	mov [__r0],A
	mov A,[__r2]
	or A,[__r0]
	mov REG[-128],A
L15:
	.dbline 59
;     
;   if ((lpf2 < AGC_UP_THESHOLD) && (gain_level < AGC_GAIN_HIGH))
	mov A,[L4]
	xor A,-128
	mov [__rY],A
	mov A,15
	xor A,-128
	mov [__rZ],A
	mov [__rX],0
	mov A,[L4+1]
	sub A,-96
	or [__rX],A
	mov A,[__rY]
	sbb A,[__rZ]
	or [__rX],A
	jnc L17
	mov A,[__rX]
	jz L17
X2:
	cmp [_gain_level],6
	jnc L17
X3:
	.dbline 60
;       In_BPF_FILT_C1_REG = (In_BPF_FILT_C1_REG & 0xE0) | gain_table[++gain_level]; 
	mov A,[_gain_level]
	add A,1
	mov [__r0],A
	mov [_gain_level],A
	mov A,REG[-128]
	mov [__r2],A
	and [__r2],-32
	mov [__r1],[__r0]
	mov [__r0],0
	add [__r1],<_gain_table
	adc [__r0],>_gain_table
	mov A,[__r0]
	push X
	mov X,[__r1]
	romx
	pop X
	mov [__r0],A
	mov A,[__r2]
	or A,[__r0]
	mov REG[-128],A
L17:
	.dbline 63
	mov [L5],6
	xjmp L20
L19:
	.dbline 63
	.dbline 63
	mov [__r1],[L5]
	mov [__r0],0
	asl [__r1]
	rlc [__r0]
	add [__r1],<_hpf_buffer
	adc [__r0],>_hpf_buffer
	mov [__r3],[L5]
	mov [__r2],0
	sub [__r3],1
	sbb [__r2],0
	asl [__r3]
	rlc [__r2]
	add [__r3],<_hpf_buffer
	adc [__r2],>_hpf_buffer
	mvi A,[__r3]
	mov [__r2],A
	mvi A,[__r3]
	mov [__r3],A
	mov A,[__r2]
	mvi [__r1],A
	mov A,[__r3]
	mvi [__r1],A
	.dbline 63
	dec [L5]
	.dbline 63
L20:
	.dbline 63
; 
;       
;   loop = HPF_BUFFER_LEN-1; while(loop) {hpf_buffer[loop] = hpf_buffer[loop-1]; loop--;}
	cmp [L5],0
	jnz L19
	.dbline 64
;   hpf_buffer[0] = lpf2;    
	mov [_hpf_buffer+1],[L4+1]
	mov [_hpf_buffer],[L4]
	.dbline 66
;   
;   hpf_data = hpf_buffer[6] - hpf_buffer[0];
	mov A,[_hpf_buffer+12+1]
	sub A,[_hpf_buffer+1]
	mov [L6+1],A
	mov A,[_hpf_buffer+12]
	sbb A,[_hpf_buffer]
	mov [L6],A
	.dbline 68
;   
;   temp = hpf_buffer[1] - hpf_buffer[5];
	mov A,[_hpf_buffer+2+1]
	sub A,[_hpf_buffer+10+1]
	mov [L7+1],A
	mov A,[_hpf_buffer+2]
	sbb A,[_hpf_buffer+10]
	mov [L7],A
	.dbline 69
;   hpf_data += temp;
	mov A,[L7+1]
	add [L6+1],A
	mov A,[L7]
	adc [L6],A
	.dbline 70
;   temp <<= 3; 
	asl [L7+1]
	rlc [L7]
	asl [L7+1]
	rlc [L7]
	asl [L7+1]
	rlc [L7]
	.dbline 71
;   hpf_data += temp;
	mov A,[L7+1]
	add [L6+1],A
	mov A,[L7]
	adc [L6],A
	.dbline 73
;   
;   temp = hpf_buffer[4] - hpf_buffer[2];
	mov A,[_hpf_buffer+8+1]
	sub A,[_hpf_buffer+4+1]
	mov [L7+1],A
	mov A,[_hpf_buffer+8]
	sbb A,[_hpf_buffer+4]
	mov [L7],A
	.dbline 74
;   hpf_data -= temp;
	mov A,[L7+1]
	sub [L6+1],A
	mov A,[L7]
	sbb [L6],A
	.dbline 75
;   temp <<= 1;
	asl [L7+1]
	rlc [L7]
	.dbline 76
;   hpf_data -= temp;
	mov A,[L7+1]
	sub [L6+1],A
	mov A,[L7]
	sbb [L6],A
	.dbline 77
;   temp <<= 3;
	asl [L7+1]
	rlc [L7]
	asl [L7+1]
	rlc [L7]
	asl [L7+1]
	rlc [L7]
	.dbline 78
;   hpf_data += temp;
	mov A,[L7+1]
	add [L6+1],A
	mov A,[L7]
	adc [L6],A
	.dbline 79
;   temp <<= 1;
	asl [L7+1]
	rlc [L7]
	.dbline 80
;   hpf_data += temp;
	mov A,[L7+1]
	add [L6+1],A
	mov A,[L7]
	adc [L6],A
	.dbline 82
;      
;   if (RANGE_POINTS == ran_cnt++)
	mov [__r1],[L8]
	mov [__r0],0
	mov A,[__r1]
	add A,1
	mov [__r3],A
	mov A,0
	adc A,0
	mov [L8],[__r3]
	cmp [__r0],0
	jnz L27
	cmp [__r1],-56
	jnz L27
X4:
	.dbline 83
;   {
	.dbline 84
;      temp = th + TH_DELTA;
	mov A,[L9+1]
	add A,-56
	mov [L7+1],A
	mov A,[L9]
	adc A,0
	mov [L7],A
	.dbline 86
;      
;      th += (adc_max >> (TH_FILTER_SHIFT+1)) - (th >> TH_FILTER_SHIFT);
	mov [__r1],[L10+1]
	mov [__r0],[L10]
	asr [__r0]
	rrc [__r1]
	asr [__r0]
	rrc [__r1]
	mov [__r3],[L9+1]
	mov [__r2],[L9]
	asr [__r2]
	rrc [__r3]
	mov A,[__r3]
	sub [__r1],A
	mov A,[__r2]
	sbb [__r0],A
	mov A,[__r1]
	add [L9+1],A
	mov A,[__r0]
	adc [L9],A
	.dbline 87
;      th = MIN(th, temp);
	mov A,[L9]
	xor A,-128
	mov [__rY],A
	mov A,[L7]
	xor A,-128
	mov [__rZ],A
	mov [__rX],0
	mov A,[L9+1]
	sub A,[L7+1]
	or [__rX],A
	mov A,[__rY]
	sbb A,[__rZ]
	or [__rX],A
	jnc L30
	mov A,[__rX]
	jz L30
X5:
	mov A,[L9+1]
	mov [X+1],A
	mov A,[L9]
	mov [X+0],A
	xjmp L31
L30:
	mov A,[L7+1]
	mov [X+1],A
	mov A,[L7]
	mov [X+0],A
L31:
	mov A,[X+1]
	mov [L9+1],A
	mov A,[X+0]
	mov [L9],A
	.dbline 89
;      
;      if (th < TH_MIN) th = TH_MIN;
	mov A,[L9]
	xor A,-128
	mov [__rY],A
	mov A,1
	xor A,-128
	mov [__rZ],A
	mov [__rX],0
	mov A,[L9+1]
	sub A,44
	or [__rX],A
	mov A,[__rY]
	sbb A,[__rZ]
	or [__rX],A
	jnc L32
	mov A,[__rX]
	jz L32
X6:
	.dbline 89
	mov [L9+1],44
	mov [L9],1
L32:
	.dbline 90
;      if (th > TH_MAX) th = TH_MAX;
	mov A,[L9]
	xor A,-128
	mov [__rY],A
	mov A,5
	xor A,-128
	mov [__rZ],A
	mov [__rX],0
	mov A,[L9+1]
	sub A,-36
	or [__rX],A
	mov A,[__rY]
	sbb A,[__rZ]
	or [__rX],A
	jc L34
	mov A,[__rX]
	jz L34
X7:
	.dbline 90
	mov [L9+1],-36
	mov [L9],5
L34:
	.dbline 92
;      
;      adc_max_prev = adc_max;
	mov [_adc_max_prev+1],[L10+1]
	mov [_adc_max_prev],[L10]
	.dbline 93
;      adc_max = ran_cnt = 0;
	mov [L8],0
	mov [L10+1],0
	mov [L10],0
	.dbline 94
;   } 
	xjmp L28
L27:
	.dbline 96
;     else       
;       if (hpf_data > adc_max)  adc_max = hpf_data;
	mov A,[L6]
	xor A,-128
	mov [__rY],A
	mov A,[L10]
	xor A,-128
	mov [__rZ],A
	mov [__rX],0
	mov A,[L6+1]
	sub A,[L10+1]
	or [__rX],A
	mov A,[__rY]
	sbb A,[__rZ]
	or [__rX],A
	jc L36
	mov A,[__rX]
	jz L36
X8:
	.dbline 96
	mov [L10+1],[L6+1]
	mov [L10],[L6]
L36:
L28:
	.dbline 98
;       
;   int_cnt++;
	inc [L12+1]
	adc [L12],0
	.dbline 100
;   
;   if (hpf_data < th)       
	mov A,[L6]
	xor A,-128
	mov [__rY],A
	mov A,[L9]
	xor A,-128
	mov [__rZ],A
	mov [__rX],0
	mov A,[L6+1]
	sub A,[L9+1]
	or [__rX],A
	mov A,[__rY]
	sbb A,[__rZ]
	or [__rX],A
	jnc L38
	mov A,[__rX]
	jz L38
X9:
	.dbline 101
;   {
	.dbline 102
;     if (peak_max > 0)
	mov A,[L11]
	xor A,-128
	mov [__rY],A
	mov A,0
	xor A,-128
	mov [__rZ],A
	mov [__rX],0
	mov A,[L11+1]
	sub A,0
	or [__rX],A
	mov A,[__rY]
	sbb A,[__rZ]
	or [__rX],A
	jc L39
	mov A,[__rX]
	jz L39
X10:
	.dbline 103
;     {
	.dbline 104
;        if (peak_ind > peak_ind_old) peak_delta = peak_ind - peak_ind_old;
	mov A,[L13]
	cmp A,[L14]
	jnz X12
	mov A,[L13+1]
	cmp A,[L14+1]
	jz L42
X12:
	jc L42
X11:
	.dbline 104
	mov A,[L13+1]
	sub A,[L14+1]
	mov [_peak_delta+1],A
	mov A,[L13]
	sbb A,[L14]
	mov [_peak_delta],A
	xjmp L43
L42:
	.dbline 106
;        else
;        {
	.dbline 107
;          peak_delta = PULSE_INTERVAL_MAX - peak_ind_old;
	mov A,-1
	sub A,[L14+1]
	mov [_peak_delta+1],A
	mov A,-1
	sbb A,[L14]
	mov [_peak_delta],A
	.dbline 108
;          peak_delta += peak_delta + 1;
	mov A,[_peak_delta+1]
	add A,1
	mov [__r1],A
	mov A,[_peak_delta]
	adc A,0
	mov [__r0],A
	mov A,[__r1]
	add [_peak_delta+1],A
	mov A,[__r0]
	adc [_peak_delta],A
	.dbline 109
;        }      
L43:
	.dbline 110
;        peak_ind_old = peak_ind;
	mov [L14+1],[L13+1]
	mov [L14],[L13]
	.dbline 111
;        peak_max = 0;  
	mov [L11+1],0
	mov [L11],0
	.dbline 112
;     }  
	.dbline 113
;   }      
	xjmp L39
L38:
	.dbline 115
;   else
;     if (hpf_data > peak_max) 
	mov A,[L6]
	xor A,-128
	mov [__rY],A
	mov A,[L11]
	xor A,-128
	mov [__rZ],A
	mov [__rX],0
	mov A,[L6+1]
	sub A,[L11+1]
	or [__rX],A
	mov A,[__rY]
	sbb A,[__rZ]
	or [__rX],A
	jc L44
	mov A,[__rX]
	jz L44
X13:
	.dbline 116
;     {
	.dbline 117
;       peak_max = hpf_data;
	mov [L11+1],[L6+1]
	mov [L11],[L6]
	.dbline 118
;       peak_ind = int_cnt;
	mov [L13+1],[L12+1]
	mov [L13],[L12]
	.dbline 119
;     }      
L44:
L39:
	.dbline -2
	.dbline 120
; }
L2:
	add SP,-2
	pop X
	pop A
	mov [__rZ],A
	pop A
	mov [__rY],A
	pop A
	mov [__rX],A
	pop A
	mov [__r3],A
	pop A
	mov [__r2],A
	pop A
	mov [__r1],A
	pop A
	mov [__r0],A
	pop A
	.dbline 0 ; func end
	reti
	.dbend
	.dbfunc e GetADCRange _GetADCRange fI
;           temp -> X+0
_GetADCRange::
	.dbline -1
	push X
	mov X,SP
	add SP,2
	.dbline 124
; 
; 
; INT GetADCRange(void)
; {
	.dbline 127
;   INT temp;
;   
;   M8C_DisableGInt;
		and F, FEh

	.dbline 128
;   temp = adc_max_prev;
	mov A,[_adc_max_prev+1]
	mov [X+1],A
	mov A,[_adc_max_prev]
	mov [X+0],A
	.dbline 129
;   M8C_EnableGInt; 
		or  F, 01h

	.dbline 131
;   
;   return temp; 
	mov A,[X+1]
	mov [__r1],A
	mov A,[X+0]
	mov [__r0],A
	.dbline -2
L46:
	add SP,-2
	pop X
	.dbline 0 ; func end
	ret
	.dbsym l temp 0 I
	.dbend
	.dbfunc e GetPulseDelta _GetPulseDelta fi
;           temp -> X+0
_GetPulseDelta::
	.dbline -1
	push X
	mov X,SP
	add SP,2
	.dbline 135
; }
; 
; PULSE_INTERVAL_TYPE GetPulseDelta(void)
; {
	.dbline 138
;   PULSE_INTERVAL_TYPE temp;
;   
;   M8C_DisableGInt;
		and F, FEh

	.dbline 139
;   temp = peak_delta;
	mov A,[_peak_delta+1]
	mov [X+1],A
	mov A,[_peak_delta]
	mov [X+0],A
	.dbline 140
;   peak_delta = 0;
	mov [_peak_delta+1],0
	mov [_peak_delta],0
	.dbline 141
;   M8C_EnableGInt; 
		or  F, 01h

	.dbline 143
;   
;   return temp;
	mov A,[X+1]
	mov [__r1],A
	mov A,[X+0]
	mov [__r0],A
	.dbline -2
L47:
	add SP,-2
	pop X
	.dbline 0 ; func end
	ret
	.dbsym l temp 0 i
	.dbend
	.dbfunc e GetGainLevel _GetGainLevel fc
_GetGainLevel::
	.dbline -1
	.dbline 147
; }
; 
; BYTE GetGainLevel(void)
; {
	.dbline 148
;   return gain_level;
	mov A,[_gain_level]
	.dbline -2
L48:
	.dbline 0 ; func end
	ret
	.dbend
	.area bss(ram, con, rel)
	.dbfile ./sigproc.c
_hpf_buffer:
	.blkb 14
	.dbsym s hpf_buffer _hpf_buffer A[14:7]I