Hello,

I want to measure a ~ 3 msec low-high-low pulse that repeats every ~ 30 msec.  Then I need to compare the ratio of 10:1 for calibrating the device.  

I'd like to do an event-count of the resonator clock cycles (or some other oscillator that I could provide if the microcontroller likes this better  :cool: ).  I would count 1] while the pulse is high, and 2] count from the first high pulse until the next high pulse, then compare the two counts.  

Can the SX family handle that?  Is there a better parallax product for this project?  

Thanks very much for your help.

The SX can EASILY handle this chore -- and there have been several threads in recent days on this topic.

PULSIN is built into SX/B's vocabulary, though it may not have enough resolution (10 microseconds).  Look for recent threads having to do with measuring servo pulses; a couple of us demonstrated replacing PULSIN with interrupt driven code; code that can easily be modified for any resolution you like.

Let me ponder this over lunch -- there's more than one way to skin a cat.

Have a look at the attached program -- should get you close.  There is a function that will wait on the 0->1 edge, measure the high portion, the low portion, then return those values to the caller (the program shows how to retrieve more than two bytes from a single function call).  If you are certain that your pulses are less than 65 milliseconds wide then you can remove the check that aborts the timing loop on a rollover.

Hello Jim;

Just foir fun I wanted to see how tight one could create some assembler code to do what I think you are looking to accomplish. The code must use ra.1 as the high/low input, and will count the duration (2 bytes) that a continuous high or low is detected. When that input pin transitions to the opposite state (say low), the accumulated count is output on ports e/d, and the counter is zroed. The accumulation starts again, and when the input again transitions (now high), the accumulated count is put on ports c/b. This way you can separately see the high and low results in real time via leds connected to those 32 port pins.
Although fairly short, the program is quite intricate -even tricky in spots- and ANY alteration will cause it to fail unless certain timing/code length principles are upheld. As it stands, it will (just) work up to minimum durations of 440 nano seconds, and that's its resolution.
Sixteen bit accumulators permit 65355 counts to be captured, so at the programmed speed of 440 nanoseconds, permits a slowest duration of .44 x 65535 = 28.8 milliseconds... perhaps just outside your range. If that is the case, one could safely slow the interrupt period down from minus 22 cycles to minus 25 cycles (as in the commented out "INTVAL EQU -25 " line, and that would yield a 500 nano second resolution. Then the slowest you could capture (that is per high OR per low duration) would be .5 x 65535 = 32.7 milliseconds.

device SX48,oscHS3    ; new assembler
id'Ratio1'
freq 50_000_000 ; default run speed = 50MHz
reset reset_entry ; JUMP to start label on reset 
  
IntVal  equ -22     ;440 nsec resolution at 50 MHz (can be made slower, but not faster for this EXACT code)
;IntVal  equ -25     ;500 nsec resolution at 50 MHz (can be made slower, but not faster for this EXACT code) 

Low   equ rb
High  equ rd 

  org $0A
IntCtrLo           ds 1
IntCtrHi           ds 1 
  
watch Low,16,uhex
watch High,16,uhex
watch IntCtrLo,16,uhex 
  
  org 0
Intsvc incsz IntCtrLo   ;keep track of interrupt events
       skip
       inc  IntCtrHi
       rl  ra           ;input on ra.1
       mov  w,<<ra
       and  w,#%0001_1000
       add  pc,w 
  
Add00  mov  w,#IntVal   ;aligned on plus 0 boundary 
       retiw      
  
       nop       ;these nops
       nop       ;must be located
       nop       ;precisely here to
       nop       ;park the "ADD TO PC"
       nop       ;state code at
       nop       ;the proper spots 
  
Add01  mov  w,IntCtrLo   ;aligned on plus 8 boundary 
       mov  rb,w
       mov  w,IntCtrHi
       mov  rc,w
       clr  IntCtrLo
       clr  IntCtrHi
       mov  w,#IntVal    ;
       retiw      ; 
  
Add10  mov  w,IntCtrLo   ;aligned on plus 16 boundary 
       mov  rd,w
       mov  w,IntCtrHi
       mov  re,w
       clr  IntCtrLo
       clr  IntCtrHi
       mov  w,#IntVal    ;
       retiw      ; 
  
Add11  mov  w,#IntVal   ;aligned on plus 24 boundary 
       retiw       

Reset_entry             ;Program starts here on power-up and on reset. 
Init   mov  m,#$0d     ;Set 0 for CMOS levels
       mov  !ra,#%0000_0000  
       mov  !rb,#%0000_0000  
       mov  !rc,#%0000_0000  
       mov  !rd,#%0000_0000  
       mov  !re,#%0000_0000  
       mov  m,#$0e     ;Set 0 for pullups
       mov  !ra,#%0000_0000  
       clr  ra
       clr  rb
       clr  rc
       clr  rd
       clr  re
       mov  m,#$0f     ;Set 0 for output
       mov  !ra,#%0000_0010   ;ra.1 is the high/low transition input
       mov  !rb,#%0000_0000  
       mov  !rc,#%0000_0000  
       mov  !rd,#%0000_0000  
       mov  !re,#%0000_0000  
       clr  rtcc
       mov  !option,#%1000_1000  ;0 = w, 0 = interrupt, 0 = internal, 0 = lo to hi, 0 = scale rtcc, xxx divide
       clr  IntCtrLo
       clr  IntCtrHi 

Main   jmp  Main     ;
       nop        ;dummy required because IDE will not "BREAK" at last program instruction 
  

Tricky?  That's an understatement, my friend! :smile: