To save the serial number to scratch memory:

ScratchData[0] := SerialNum shr 24;
ScratchData[1] := (SerialNum shr 16) and 255;
ScratchData[2] := (SerialNum shr 8) and 255;
ScratchData[3] := SerialNum and 255;

To read the serial number from scratch memory (Gennum circuits):

SerialNo := 
  (ScratchData[0] shl 24) + 
  (ScratchData[1] shl 16) +
  (ScratchData[2] shl 8) + 
  ScratchData[3];

Operators

Instrument Model Code is selected from this table:

Instructions:

Use the lower 8 bits of Word 2 to indicate all of the models. Make each combination of shell size and circuit to be a unique model number.

This method works nicely because each model has a set of associated transducer curves. This scheme allows 256 model combinations if we only use the lower 8 bits of word 2, but we could use all 16 bits, if necessary, and not have any practical limitation on the number of models into the future.

Starting with ezFIT 4.20, supporting the Ethos circuit, model codes start at 00 for every new circuit. Previous circuits are kept with the original notations, for backwards compatibility. Basically, instruments are uniquely identified by the CircuitID + ProductID + StyleID. See Guaranteeing Unique Circuit Instrument References for a more detailed explanation.

To save the field ProdAndStyleID manufacturer's reserved space:

procedure TEzNzBase.SetFieldProdAndStyleID(ProdAndStyleID: integer; var Word2: word);
var
  BitMask: word;
begin
  // word2 format in bits: xPPP PVVV IIII IIII (x=UsingInSitu, P=prescription, V=VCpos, I=ProdAndStyleID)
 
  // store ProdAndStyleID code:
  // 1. clear ProdAndStyleID field using bitmask.
  // 2. store ProdAndStyleID field (and preserve other data in Word2).
 
  BitMask := 255;   // 0000 0000 1111 1111
  Word2 := (Word2 and not BitMask) {clear field} xor ProdAndStyleID {store};
end;

To read the field ProdAndStyleID from manufacturer's reserved space:

function TEzNzBase.GetFieldProdAndStyleID(word2: word): integer;
var
  BitMask: word;
begin
   // word2 format in bits: xPPP PVVV IIII IIII (x=UsingInSitu, P=prescription, V=VCpos, I=ProdAndStyleID)
   BitMask := 255; {bitmask of 8-bits}
   result  := (Word2 and BitMask);
end;

Serial Number storage format:

SerialNumber = 05108567 (Format: YearCode + Serial Upper 8-bits + Serial Lower 16-bits)
YearCode = CalendarYear - 2000

To save the serial number to manufacturer's reserved space:

  procedure SetRTISerialNum(SerialNum: integer; var Word1, Word3, Word4: word);
  var
      BitMask: word;
      YearCode: string;
      PlainSerialNumStr: string;
      PlainSerialNum: integer;
  begin
      YearCode          := Copy( Format('%.8d',[SerialNum]), 1, 2);  // extract yearcode
      PlainSerialNumStr := Copy( Format('%.8d',[SerialNum]), 3, 6);  // extract just serial number (no yearcode included)
      PlainSerialNum    := StrToInt(PlainSerialNumStr);
 
      // store yearcode used in serial number:
      // 1. clear yearcode field using bitmask.
      // 2. store yearcode field (and preserve other data in Word1).
      BitMask := 65472;   // binary equiv: 1111 1111 1100 0000
      Word1 := (Word1 and Bitmask {clear field}) xor StrToInt(YearCode) {store};
 
      // store serial number by spliting its 24-bit content between Word3 and Word4
      //Word3 := PlainSerialNum shr 16;       // strip lower 16-bits & store only upper 8-bits (shift right 16 places (bits) of this 24-bit code)
      BitMask := 65280;   // binary equiv: 1111 1111 0000 0000
      Word3 := (Word3 and Bitmask {clear field}) xor (PlainSerialNum shr 16);       // strip lower 16-bits & store only upper 8-bits (shift right 16 places (bits) of this 24-bit code)
      Word4 := PlainSerialNum and 65535;    // store in entire word4 (bitmask 65535 has all 32 bits on)
  end;

To read the serial number from manufacturer's reserved space:

function GetRTISerialNum(word1, word3, word4: word): integer;
var
    YearCode: string;
    SerialNum: integer;
begin
    //--------------------------------------------
    //      1111 1111 11xx xxxx  (Word1)
    //  AND 0000 0000 0011 1111  (63 bitmask)  YearCode can be max 2063 (i.e. 63)
    //  -----------------------
    //      0000 0000 00xx xxxx  (YearCode)
    //--------------------------------------------
    YearCode  := format('%.2d', [Word1 and 63] );                    // 63 = bitmask 111111 (6-bits)
    SerialNum := ((Word3 and 255 {upper 8-bits}) shl 16 ) + Word4 {lower 16-bits}; // create basic serial number
    SerialNum := StrToInt(format('%s%.6d', [YearCode, SerialNum]));  // add yearcode to serial number
    result    := SerialNum;
end;

Set the audiogram data in the scratch memory. 10 frequencies are stored in 50 bits, representing each value as a 5 bit number. The value stored is the hearing threshold divided by 5. This is rounded to the nearest 5, so 26 becomes 5 and 48 becomes 10. The minimum stored value is 0, the maximum stored value is 150.

//------------------------------------------------------------------------------
// Procedure  : SetScratchMemAudiogram
// Description: To save the audiogram to manufacturer's reserve space (RTI circuits)
// Arguments  : Autofit: integer; var Word3: word
// Result     : None
//------------------------------------------------------------------------------
procedure TEzNzBase.SetScratchMemAudiogram(AnAudiogram: TAudiogram;
             var Word1: word; var Word5: word; var Word6: word; var Word7: word);
var
  BitMask: word;
  CompressedAudiogram: array [0..6] of Byte;
  i, BytePos, BitPos, BitPosInByte, FreqIdx, Overflow: integer;
  CompressedGainVal: Byte;
begin
  if FHasAudiogram then begin       // only store to hearing aid if Audiogram exist
    for i:=0 to high(CompressedAudiogram) do begin
      CompressedAudiogram[i] := 0;  // clear all bits
    end;
 
    // encode audiogram
    for FreqIdx := 0 to AnAudiogram.Highest {9} do begin
      BitPos       := FreqIdx * 5;
      BitPosInByte := BitPos mod 8;
      BytePos      := BitPos div 8;
      Overflow     := (5 {field size in bits} - (8 {bitsperbyte} - BitPosInByte {good bits}));
      BitMask      := 31;                                // binary equiv: 0000 0000 0001 1111
      BitMask      := (not (BitMask shl BitPosInByte));  // binary equiv: 1111 1111 1110 0000 (if BitPosInType = 0)
 
      // let's calculate compressed gain value
      if AnAudiogram.FOriginal[FreqIdx] <> -1 then begin       // if Gain in current frequency is not empty (-1) ...
        CompressedGainVal := (AnAudiogram.FOriginal[FreqIdx] div 5);
      end else begin
        CompressedGainVal := 31;   // code for empty field (-1)
      end;
 
      // store first part of freq value (gain index, actually)
      // gain index = (gain value @ freq) / 5
      // Gain in current frequency is not empty (-1). Let's store it
      CompressedAudiogram[BytePos] := (CompressedAudiogram[BytePos] and BitMask {clear field}) xor
                                      (CompressedGainVal shl BitPosInByte) {store};
 
      // store overflow bits in next byte (second part of freq value, if there is overflow in previous storage unit)
      if Overflow > 0 then begin
        //BitMask := GetBitMask(5 {field size in bits} - (8 {bitsperbyte} - Overflow));  // get count of missing bits that need storing
        //GetBitMask(Overflow);              // get bitmask based on count of missing bits that need storing
        BitMask := 65535 shl Overflow; // get bitmask based on count of missing bits that need storing
        CompressedAudiogram[BytePos+1] := (CompressedAudiogram[BytePos+1] and BitMask {clear field}) xor
                                          (CompressedGainVal shr (5 {fieldsize} - Overflow) {store}); {store only missing bits}
      end; {endif}
    end; {endfor}
 
    // store compressed audiogram:
    // 1. clear audiogram field using bitmask.
    // 2. store audiogram field (and preserve other data in Word1 and Word5..Word7).
    //BitMask := 65343;               // binary equiv: 1111 1111 0011 1111
    BitMask := (3 shl 6);             // binary equiv: 0000 0000 1100 0000
    BitMask := not BitMask;           // binary equiv: 1111 1111 0011 1111
    Word1   := (Word1 and BitMask {clear field}) xor (CompressedAudiogram[6] shl 6 {store});  // upper 2-bits
    Word5   := (Word5 and 0 {clear field}) xor CompressedAudiogram[4] {store} xor (CompressedAudiogram[5] shl 8) {store};   // upper 16-bits
    Word6   := (Word6 and 0 {clear field}) xor CompressedAudiogram[2] {store} xor (CompressedAudiogram[3] shl 8) {store};   // mid 16-bits
    Word7   := (Word7 and 0 {clear field}) xor CompressedAudiogram[0] {store} xor (CompressedAudiogram[1] shl 8) {store};   // lower 16-bits
  end; //endif
 
end;

Get the audiogram data from the scratch memory:

//------------------------------------------------------------------------------
// Procedure  : GetScratchMemAudiogram
// Description: To read the audiogram from manufacturer's reserve space (RTI circuits)
// Arguments  : Word1, Word5, Word6, Word7: word; var AnAudiogram: array of integer;
// Result     : void
//------------------------------------------------------------------------------
function TEzNzBase.GetScratchMemAudiogram(Word1, Word5, Word6, Word7: word;
                               var AnAudiogram: array of integer): Boolean;
var
  CompressedAudiogram: array [0..6] of Byte;
  AudiogramFromInstrument: array [0..9] of integer;
  BitMask: word;
  i, BytePos, BitPos, BitPosInByte, GainIdx, GainVal, FreqIdx, Overflow: integer;
  AudiogramExists: Boolean;
begin
  AudiogramExists := False;
  for i:=0 to high(CompressedAudiogram) do begin
    CompressedAudiogram[i] := 0;  // clear all bits
  end;
 
  // unpack data
  CompressedAudiogram[0] := (Word7 and (255 shl 0)) shr 0; // lower freq
  CompressedAudiogram[1] := (Word7 and (255 shl 8)) shr 8;
  CompressedAudiogram[2] := (Word6 and (255 shl 0)) shr 0; // mid freq
  CompressedAudiogram[3] := (Word6 and (255 shl 8)) shr 8;
  CompressedAudiogram[4] := (Word5 and (255 shl 0)) shr 0; // upper freq
  CompressedAudiogram[5] := (Word5 and (255 shl 8)) shr 8;
  CompressedAudiogram[6] := (Word1 and (3   shl 6)) shr 6; // remaining upper 2-bits
 
  // check whether we have an audiogram
  for i:=0 to High(CompressedAudiogram) do begin
    if CompressedAudiogram[i] <> 0 then begin
      AudiogramExists := True;   // we have an audiogram stored
    end;
  end;
 
  if AudiogramExists then begin
    // decode audiogram (stored in bitmap)
    BitMask := 31;  {Bitmask = 11111}
    for FreqIdx := 0 to 9 do begin
      // init variables
      BitPos       := (FreqIdx * 5);
      BitPosInByte := BitPos mod 8;
      BytePos      := BitPos div 8;
      Overflow     := (5 {field size in bits} - (8 {bitsperbyte} - BitPosInByte {good bits}));
 
      // get gain value for current frequency
      GainIdx := (CompressedAudiogram[BytePos] and
                 (BitMask shl BitPosInByte) {extract}) shr BitPosInByte {store as Int};
      if Overflow > 0 then begin
        GainIdx := GainIdx xor
                   (CompressedAudiogram[BytePos+1] and
                   (BitMask shr (8 {bitsperbyte} - BitPosInByte {good bits})) {extract}) shl
                   (8 {bitsperbyte} - BitPosInByte) {store as Int};
      end;
      if (GainIdx <> 31) and (GainIdx <> 0) then begin
        GainVal := GainIdx * 5;  // get gain value (based on gain index)
      end else begin
        GainVal := -1;           // gain value is empty (-1)
      end;
      AudiogramFromInstrument[FreqIdx] := GainVal;
    end;
 
    for i:=0 to high(AudiogramFromInstrument) do begin
      AnAudiogram[i] := AudiogramFromInstrument[i];
    end;
 
  end;
 
  result := AudiogramExists;
 
end;

To save the prescription type to manufacturer's reserved space:

procedure TEzNzBase.SetFieldPrescriptionType(Prescription: TNZPrescriptionType; var Word2: word);
var
  ValToStore, BitMask: word;
begin
  // word2 format in bits: xPPP PVVV IIII IIII (x=UsingInSitu, P=prescription, V=VCpos, I=ProdAndStyleID)
 
  //                                                                        0xx xx|<-----------
  // Move data (prescription) to correct location by shifting-left 11 bits: 0XXX X000 0000 0000.
  ValToStore := (integer(Prescription) shl 11 {move});
 
  // Note: we only suport up to 15 possible prescriptions, i.e. we only save
  //       4 bits of Prescription. The bitmask takes care of that.
  BitMask := 34815;  // binary equivalent: 1000 0111 1111 1111
 
  // Clear Prescription field, then store new value while preserving old data in Word1
  // Eg: 1. Clear field:   x001 0xxx xxxx xxxx --> x000 0xxx xxxx xxxx
  //     2. Store value 5: x000 0xxx xxxx xxxx --> x010 1xxx xxxx xxxx (and preseve other data)
  Word2 := (Word2 and Bitmask {clear field}) xor ValToStore {store};
end;

To read the prescription type from manufacturer's reserved space:

  function GetFieldPrescriptionType(word2: word): TNZPrescriptionType;
  begin
     // move 11 bits to right, and extract 4 bits (bitmask 15(dec)=1111(bin))
     result := TNZPrescriptionType( (Word2 shr 11) and 15 );
  end;

To save the Autofit Settings to manufacturer's reserved space:

procedure TEzNzBase.SetFieldAutofitSettings(Autofit: TAutofitSettings; var Word1: word; var Word3: word);
var
  BitMask: word;
begin
  // store autofit code:
  // 1. clear autofitcode field using bitmask.
  // 2. store autofitcode field (and preserve other data in Word1 and Word3).
 
  BitMask := 15;   // 0000 0000 0000 1111
  Word3 := (Word3 and not (BitMask shl  8) {clear field}) xor (Autofit.MemoryA shl  8) {store};
  Word3 := (Word3 and not (BitMask shl 12) {clear field}) xor (Autofit.MemoryB shl 12) {store};
  Word1 := (Word1 and not (BitMask shl  8) {clear field}) xor (Autofit.MemoryC shl  8) {store};
  Word1 := (Word1 and not (BitMask shl 12) {clear field}) xor (Autofit.MemoryD shl 12) {store};
 
end;

To read the prescription type from manufacturer's reserved space:

procedure TEzNzBase.GetFieldAutofitSettings(Word1, Word3: word; var Autofit: TAutofitSettings);
var
  BitMask: integer;
begin
  // get field values (each 6-bit long)
  BitMask := 15;   // 0000 0000 0000 1111
  Autofit.MemoryA := (Word3 and (BitMask shl  8)) shr  8;
  Autofit.MemoryB := (Word3 and (BitMask shl 12)) shr 12;
  Autofit.MemoryC := (Word1 and (BitMask shl  8)) shr  8;
  Autofit.MemoryD := (Word1 and (BitMask shl 12)) shr 12;
end;

To save the field UsingInSituAudiogram to manufacturer's reserved space:

procedure TEzNzBase.SetFieldUsingInSituAudiogram(UsingInSituAudiogram: Boolean; var Word2: word);
var
  BitMask: word;
begin
  // store UsingInSituAudiogram code:
  // 1. clear UsingInSituAudiogram field using bitmask.
  // 2. store UsingInSituAudiogram field (and preserve other data in Word2).
 
  BitMask := 1;   // 0000 0000 0000 0001
  Word2 := (Word2 and not (BitMask shl  15) {clear field}) xor (integer(UsingInSituAudiogram) shl 15) {store};
end;

To read the field UsingInSituAudiogram from manufacturer's reserved space:

function TEzNzBase.GetFieldUsingInSituAudiogram(Word2: word): Boolean;
var
  BitMask: integer;
begin
  // word2 format in bits: xPPP PVVV IIII IIII (x=UsingInSitu, P=prescription, V=VCpos, I=ProdAndStyleID)
  // get UsingInSituAudiogram  setting (upper bit in word)
  BitMask := 1;   // 0000 0000 0000 0001
  result := ( ((Word2 and (BitMask shl  15)) shr  15) = 1 );
end;

To save the field VCPos manufacturer's reserved space:

procedure TEzNzBase.SetFieldVCPos(VCPos: integer; var Word2: word);
var
  BitMask: word;
begin
  // word2 format in bits: xPPP PVVV IIII IIII (x=UsingInSitu, P=prescription, V=VCpos, I=ProdAndStyleID)
 
  // store FUserVCAutofittedPos code:
  // 1. clear FUserVCAutofittedPos field using bitmask.
  // 2. store FUserVCAutofittedPos field (and preserve other data in Word2).
 
  BitMask := 7;   // 0000 0000 0000 0111
  Word2 := (Word2 and not (BitMask shl  8) {clear field}) xor (VCPos shl 8) {store};
end;

To read the field VCPos from manufacturer's reserved space:

function TEzNzBase.GetFieldVCPos(word2: word): integer;
begin
   // word2 format in bits: xPPP PVVV IIII IIII (x=UsingInSitu, P=prescription, V=VCpos, I=ProdAndStyleID)
   // move 8 bits to right, and extract 3 bits (bitmask 15(dec)=1111(bin))
   result := (Word2 shr 8) and 7 {bitmask};
end;

To save the field BTEEarhook manufacturer's reserved space:

procedure TEzNzBase.SetFieldBTEEarhook(BTEEarhook : boolean; var Word8: word);
var
  BitMask: word;
begin
  // store BTEEarhook code:
  // 1. clear BTEEarhook field using bitmask.
  // 2. store BTEEarhook field (and preserve other data in Word8).
 
  BitMask := 1;   // 0000 0000 0000 0001
  Word8 := (Word8 and not BitMask) {clear field} xor ifthen(BTEEarhook,1,0) {store};
end;

To read the field BTEEarhook from manufacturer's reserved space:

function TEzNzBase.GetFieldBTEEarhook(word8: word): Boolean;
var
  BitMask: word;
begin
   BitMask := 1; {bitmask of 1-bits}
   result  := (Word8 and BitMask)=1;
end;

To save the field TubingType manufacturer's reserved space:

procedure TEzNzBase.SetFieldTubingType(TubingType: TTubingType; var Word8: word);
var
  BitMask: word;
begin
   // this field is split in two:
   //  - Lower 1-bit is in Word8.bit00
   //  - Upper 2-bits are in Word8.bit02 & bit03
 
  // store TubingType code:
  // 1. clear lower 1-bit TubingType field using bitmask.
  // 2. store lower 1-bit TubingType field (and preserve other data in Word8).
  // 3. clear upper 2-bits TubingType field using bitmask.
  // 4. store upper 2-bits TubingType field (and preserve other data in Word8).
 
  // lower 1-bit
  BitMask := 1;   // 0000 0000 0000 0001
  //Word8   := (Word8 and not BitMask) {clear field} xor ifthen(TubingType,1,0) {store};
  Word8   := (Word8 and not BitMask) {clear field} xor (integer(TubingType) and Bitmask) {store};
 
  // upper 2-bits
  BitMask := 4;   // 0000 0000 0000 0011
  Word8   := (Word8 and not (BitMask shl 2)) {clear field} xor
             ((integer(TubingType) and (Bitmask shl 1 {mask for upper 2-bits}) {grab 2-bits}) and
             (Bitmask shl 2)) {store};
end;

To read the field TubingType from manufacturer's reserved space:

function TEzNzBase.GetFieldTubingType(word8: word): TTubingType;
var
  BitMask: word;
  lower1bit, upper2bits: word;
begin
   // this field is split in two:
   //  - Lower 1-bit is in Word8.bit00
   //  - Upper 2-bits are in Word8.bit02 & bit03
 
   // get lower 1-bit
   BitMask    := 1; {bitmask of 1-bits}
   lower1bit  := (Word8 and BitMask);
 
   // get upper 2-bits
   BitMask    := 4; {bitmask of 2-bits}
   upper2bits := (Word8 and (BitMask shl 2));
 
   result     := TTubingType((upper2bits shr 1 {move to correct position}) and lower1bit);
end;

To save the field HasDirMic manufacturer's reserved space:

procedure TEzNzBase.SetFieldHasDirMic(UsingInSituAudiogram: Boolean; var Word8: word);
var
  BitMask: word;
begin
  // store HasDirMic code:
  // 1. clear HasDirMic field using bitmask.
  // 2. store HasDirMic field (and preserve other data in Word8).
 
  BitMask := 1;   // 0000 0000 0000 0001
  Word8 := (Word8 and not (BitMask shl 1) {clear field}) xor (integer(HasDirMic) shl 1) {store};
end;

To read the field HasDirMic from manufacturer's reserved space:

function TEzNzBase.GetFieldHasDirMic(Word8: word): Boolean;
var
  BitMask: integer;
begin
  // word8 format in bits: 0000 0000 0000 00DB (D=HasDirMic, B=BTE Earhook)
 
  // get HasDirMic setting (2nd low bit in word)
  BitMask := 1;   // 0000 0000 0000 0001
  result := ( ((Word8 and (BitMask shl 1)) shr 1) = 1 );
end;

Operators