Замена микросхемы 1827ВЕ1-0000000 в Г4-164 на AVR -МК

 #include <stdio.h>
#include <stdint.h>
 
/*
int main() {
    uint16_t in = 0x4321;
 
    int t =
            (1000 * ((in & 0xf000) / (16*16*16))) + 
             (100 * ((in & 0xf00) / (16*16))) + 
              (10 * ((in & 0xf0) / 16)) + 
               (1 * ((in & 0xf) / 1));
    std::cout << t << std::endl;
    return 0;
}*/
 
 
uint8_t divmod10( uint32_t inp, uint32_t  div,  uint32_t *reminder )
{
    
*reminder=(uint32_t)  (inp % div) ;
 
return (uint8_t)  (inp/div);    
}
 
 
uint8_t *GetDigitsFromUint32_t( uint32_t in)  //"uint24_t" 
{
 uint8_t digits[5];
    /*
    digits[0]=(uint8_t)(in/100000) ;  in=in%100000;     
    digits[1]=(uint8_t)(in/10000) ;  in=in%10000;  
    digits[2]=(uint8_t)(in/1000) ;  in=in%1000;
    digits[3]=(uint8_t)(in/100) ;  in=in%100;
    digits[4]=(uint8_t)(in/10) ;  in=in%10;
    digits[5]=(uint8_t) (in);
        */    
   digits[0]=(uint8_t) divmod10(  in , 0x000186A0 /*100000*/ ,  &in );
   digits[1]=(uint8_t) divmod10(  in , 0x00002710 /*10000*/,  &in );
   digits[2]=(uint8_t) divmod10(  in , 0x000003e8 /*1000*/,  &in );
   digits[3]=(uint8_t) divmod10(  in , 0x00000064 /*100*/,  &in );
   digits[4]=(uint8_t) divmod10(  in , 0x0000000A /*10*/,  &in ); 
   digits[5]=(uint8_t) divmod10(  in , 0x00000001 /* 1*/ ,  &in );   
     
     
return (uint8_t *) digits;  
}
 
#include <iostream>
 
int main() {
    uint32_t in =  1599999;  // -> 15 9 9 9 9 9
     uint8_t *digits ; 
     digits = GetDigitsFromUint32_t(  in);
   printf("%d%d%d%d%d%d ",(int)digits[0],(int)digits[1], (int) digits[2], (int)digits[3],(int)digits[4],(int)digits[5] );   
    return 0;
}

 #include <stdio.h>
#include <stdint.h>
uint8_t  div32bit_mod (uint32_t  in, uint32_t  div,    uint32_t *mod    )
{
*mod=(uint32_t)  (in % div) ;
return (uint8_t)  (in /div);
}
 
uint8_t divmod( uint32_t inp, uint32_t  div,  uint32_t *reminder )
{
 return (uint8_t) div32bit_mod( inp,  div, reminder  );
    
}
 
 
uint8_t *GetDigitsFromUint32_t( uint32_t in)  //"uint24_t" 
{
 uint8_t digits[5];
    /*
    digits[0]=(uint8_t)(in/100000) ;  in=in%100000;     
    digits[1]=(uint8_t)(in/10000) ;  in=in%10000;  
    digits[2]=(uint8_t)(in/1000) ;  in=in%1000;
    digits[3]=(uint8_t)(in/100) ;  in=in%100;
    digits[4]=(uint8_t)(in/10) ;  in=in%10;
    digits[5]=(uint8_t) (in);
        */    
   digits[0]=(uint8_t) divmod(  in , 0x000186A0 /*100000*/ ,  &in );
   digits[1]=(uint8_t) divmod(  in , 0x00002710 /*10000*/,  &in );
   digits[2]=(uint8_t) divmod(  in , 0x000003e8 /*1000*/,  &in );
   digits[3]=(uint8_t) divmod(  in , 0x00000064 /*100*/,  &in );
   digits[4]=(uint8_t) divmod(  in , 0x0000000A /*10*/,  &in ); 
   digits[5]=(uint8_t) divmod(  in , 0x00000001 /* 1*/ ,  &in );   
     
     
return (uint8_t *) digits;  
}
 
#include <iostream>
 
int main() {
    uint32_t in =  1599999;  // -> (15) (9) (9) (9) (9) (9)
     uint8_t *digits ; 
     digits = GetDigitsFromUint32_t(  in);
   printf("%d%d%d%d%d%d ",(int)digits[0],(int)digits[1], (int) digits[2], (int)digits[3],(int)digits[4],(int)digits[5] );   
    return 0;
}

/*
 * GccApplication2.c
 *
 * Created: 29.03.2020 10:38:02
 * Author : USERPC01
 */ 
 
#include <avr/io.h>
#include <math.h>
 
uint8_t  div32bit_mod (uint32_t  in, uint32_t  div,    uint32_t *mod    )
{
uint32_t res;
    res=(uint32_t)in /div;
    
*mod=(uint32_t)  (in - (res*div)) ;
 
return (uint8_t)  res;
}
 
uint8_t divmod( uint32_t inp, uint32_t  div,  uint32_t *reminder )
{
 return (uint8_t) div32bit_mod( inp,  div, reminder  );
    
}
 
 
void  GetDigitsFromUint32_t( uint32_t in )  //"uint24_t" 
{
 uint8_t digits[5];
    /*
    digits[0]=(uint8_t)(in/100000) ;  in=in%100000;     
    digits[1]=(uint8_t)(in/10000) ;  in=in%10000;  
    digits[2]=(uint8_t)(in/1000) ;  in=in%1000;
    digits[3]=(uint8_t)(in/100) ;  in=in%100;
    digits[4]=(uint8_t)(in/10) ;  in=in%10;
    digits[5]=(uint8_t) (in);
        */    
   digits[0]=(uint8_t) divmod(  in , 0x000186A0 /*100000*/ ,  &in );
   digits[1]=(uint8_t) divmod(  in , 0x00002710 /*10000*/,  &in );
   digits[2]=(uint8_t) divmod(  in , 0x000003e8 /*1000*/,  &in );
   digits[3]=(uint8_t) divmod(  in , 0x00000064 /*100*/,  &in );
   digits[4]=(uint8_t) divmod(  in , 0x0000000A /*10*/,  &in ); 
   digits[5]=(uint8_t) divmod(  in , 0x00000001 /* 1*/ ,  &in );   
     
     
     //for example, for output to PORTD 
         PORTD=digits[0];
         PORTD=digits[1];
         PORTD=digits[2];
         PORTD=digits[3];
         PORTD=digits[4];
         PORTD=digits[5];
     
return    ; 
}
int main(void)
{
    /* Replace with your application code */
    while (1) 
    {
     uint32_t in =0; //=  1599999;  // -> 15 9 9 9 9 9  
     //for example, input from port B
     in|=(uint32_t)((uint32_t)PINB<<0);
     in|=(uint32_t)((uint32_t)PINB<<8);
     in|=(uint32_t)((uint32_t)PINB<<16);
     in|=(uint32_t)((uint32_t)PINB<<24);
     
     GetDigitsFromUint32_t(  in);   
 
 
    }
}

#define   PIN37_DDR DDRC     ;
#define PIN37_PORT  PORTC  ; use invertor after this pin
#define OUT_PIN37 PORTC0;
#define PIN39_DDR DDRC  ;
#define PIN39_PORT DDRC;
#define OUT_PIN39 PORTC1  ;use invertor after this pin
#define PIN36_DDR DDRC;
#define PIN36_PORT PORTC;
#define OUT_PIN36 PORTC2;
 
#define PORT_PIN34  PORTC;
#define PORTIN_PIN34  PINC;
#define PIN34_DDR DDRC;
#define OUT_PIN34 PORTC3;
#define IN_PIN34 PINC3;
 
 
 
 
#define ADDR_IN_LD_SYNC_POOL    0x00;
#define ADDR_IN_GCD_SYNC   0x01;
#define ADDR_INFORM_WAIT  0x02;
 
 
 
#define cbi ( PORT , BIT  )   ( (PORT)&=~(1<<(BIT)))  
#define sbi ( PORT , BIT  )   ( (PORT)|=(1<<(BIT)))  
#define out (PORTOUT, BYTE) ((PORTOUT)=(BYTE))
#define in (BYTE, PORTIN) ((BYTE)=(PORTIN))
 
 
 
 
 
 void SetPin23High()
{ 
; turn on 6dB 
 cbi (PIN23_PORT, PIN23_OUT) ;
 }
 
void SetPin23Low()
{ 
; turn off 6dB 
sbi (PIN23_PORT, PIN23_OUT) ;
}
 
 
void SetPin37Low(){     
cbi (PIN37_PORT, OUT_PIN37) ;        
}
 
void SetPin37High(){     
sbi  (PIN36_PORT, OUT_PIN36) ;    
}
  
 
void SetPin36Low(){
cbi (PIN36_PORT, OUT_PIN36) ;
}
 
void  SetPin36High(){     
sbi (PIN36_PORT, OUT_PIN36) ;    
}
 
 
void   SetPin39Low(){
cbi (PIN39_PORT, OUT_PIN39) ;
}
 
void  SetPin39High(){ 
sbi (PIN39_PORT, OUT_PIN39) ;
}
 
 
void  SetPin34Out(){ 
sbi (PIN34_DDR, OUT_PIN34) ;
}
 
void  SetPin34Input(){ 
cbi (PIN34_DDR,OUT_PIN34) ;
}
 
void  SetPin34High(){ 
sbi (PORT_PIN34,OUT_PIN34) ;
}
    
void  SetPin34Low(){ 
cbi (PORT_PIN34, OUT_PIN34) ;
}
 
 
 
 
 
 
void  InitPins(){ 
 
out (DDR_ADDR, 0x0f);    
 
 
sbi (PIN23_DDR, PIN23_OUT)  ;
sbi (PIN23_DDR, OUT_PIN37) ;
sbi (PIN36_DDR, OUT_PIN36)  ;
sbi (PIN39_DDR, OUT_PIN39) ;
cbi (PIN34_DDR, OUT_PIN34) ;
return;
} 
 
 
 
 
 
 
 
 
void Set6dBOn()
{
if (data==0) { SetPin23Low () ; } else  { SetPin23High();  } 
return;
 }
 
void  CheckPin34In()
{ 
SetPin34Input();
 if ((PORTIN_PIN34&(1<<IN_PIN34))==0) { return 0; } else {return 1;}
}
 
 
 
void  SetAddr( uint8_t  data )
{
 ; data=addr
PORT_ADDR= (data&0x0f)  ;
}
 
void  SetAddrInform()
{
 PORT_ADDR=ADDRESS_INFORM;
}
 
void  SetAddrInformInGCd() 
{
PORT_ADDR=ADDR_IN_GCD  ;
}
 
 
void  SetAddrInformInLD()
{
PORT_ADDR=ADDR_IN_LD;
}

#include "piniosubs.h"
/*
#define  ADDR_IN_LD_SYNC      
#define  ADDR_IN_GCD_SYNC   
 
#define  ADDR_SYNC_POOL 0x00
#define   ADR_SYNC  0x01
*/
#define  ADDR_INFORM_WAIT 0x02
 
 
#define  ADDR_AM_VREF    0x04
#define  ADDR_FM                0x03
#define ADDR_BLINKOFF    0x05
#define  ADDR_HFO              0x06  
#define  ADDR_SYNCSTATIC      0x07
 
#define  ADDR_SYNCBLINK  0x08
 
#define  ADDR_MODE            0x0a
 
#define  ADDR_DPKD   0x0c
#define  ADDR_LFO     0x0d
#define  ADDR_ATT      0x0e
#define  ADDR_SYNCRAM  0x0f
 
//#defineADDR_SYNCRAM  15
 
 void SetPinsDefault1(){
 
SetPin37Low() ; //    not active  , for 1 on the    on the trigger,  use invertor  and D12
SetPin39Low() ; //    not active  , for 1 on the    on the MemWr RAM, use invertor
SetPin36Low() ;   //   not active  , for 0 on the    on the multiplexer , use invertor and D12
return;
}
 
 void SendPin36Pulse(){ 
 
 _delay_us(1);
SetPin36High();  // send pulse 
_delay_us(20);
SetPin36Low;    //not active  
_delay_us(50);
}
 
 
 void SendPin37Pulse(){
_delay_us(1);
 SetPin37High(); //  send pulse 
_delay_us(20);
SetPin37Low() ;    //not active   
_delay_us(50) ;
}
 
 
 
 void SendPin39Pulse(){
 
_delay_us(1);
SetPin39High() ;  //send pulse 
_delay_us(20) ;
SetPin39Low() ;    //not active  , for 1 on the    on the trigger,  use invertor  and D12
_delay_us(50) ;
}
 
 
uint8_t  GetBitInformLD()
{  
 SetPinsDefault1() ;
//SetPin34Input ;  
 
SetAddrInformInLD() ;
SetPin34Input() ; 
uint8_t tmp = 0x00;
if ((PORTIN_PIN34&(1<< IN_PIN34))!=0 ) {tmp=0x01; }
return tmp; 
}
 
 
 void  SendStrobeSync(uint8_t addr){   
 SetPinsDefault1() ;
 SetPin34Out() ; 
 SetAddrSync(addr) ;  
 SendPin36Pulse ;
}
 
 
 
 
uint8_t GetBitInformGCd()
{
 
 SetPin34Input() ; 
 SetPinsDefault1() ;
 SetAddrInformInGCd() ;
 SetPin34Input() ; 
 
 SendStrobeSync (ADDR_SYNC) ;
 SetPin34Input() ;
uint8_t tmp =0x00;
if((PORTIN_PIN34&(1<<IN_PIN34))!=0) { tmp=0x01; } 
return tmp;
}
 
 
 
void SendPin34LowIfDataIsZero(uint8_t data )
{
 if (data!=0x00)  { SetPin34High();  } else { SetPin34Low();  }
return;
}
 
 
 
void SendBitInform(uint8_t data)  
 {
 SetPinsDefault1();
 SetAddrInform() ;
 SetPin34Out() ;
 SendPin34LowIfDataIsZero(data);
}
 
void SendMemWrPulse()
{ 
 SetPinsDefault1() ;
 SendPin37Pulse() ;
}
 
void SendMemWrRAMPulse(){
 SetPinsDefault1() ;
 SendPin39Pulse() ;
}
 
 
void SendPin36Pulse1()
{
_delay_us(1);
SetPin36High(); //send pulse 
_delay_us(50); // fix
SetPin36Low();   not active  
_delay_us(40);  //fix 
}
 
void SendPin36Pulse2()
{
_delay_us(1);
SetPin36High(); // send pulse 
_dela_us(40);  //fix
SetPin36Low(); // not active  
_delay_40us(40);   //fix 
}
 
void SendPulseSyncInLD()
{
SetPinsDefault1() ;
SetPin34In() ; 
SetAddrSync(ADR_SYNC) ;   
SendPin36Pulse1() ; 
}
 
 
void SendPulseSyncInGCD() 
{ 
SetPinsDefault1() ;
SetPin34In() ; 
SetAddrSync(ADDR_SYNC_POOL) ; 
SendPin36Pulse2() ; 
}
 
 
uint8_t CheckFirstBit(uint8_t byte)  
{
if((byte&0x01)==0)  { return 0x00; } else  { return 0x01; } 
}
 
void Send_nInformBit_0_IfByteFalse(uint8_t byte)  
{
if ( byte ==0) { SendBitInform(0);  }  else { SendBitInform(1); }  
}
 
void Send_nInformBit_1_IfByteFalse(uint8_t byte)  
{
 if ( byte ==0) { SendBitInform(1);  }  else { SendBitInform(0); }  
}
 
 
 
void Send_nInformBit_0_IfFirtstBitTrue(uint8_t byte)  
{
if ( (byte&0x01)==0) { SendBitInform(1);  }  else { SendBitInform(0); }
} 
 
 
void Send_nInformBit_1_IfFirtstBitTrue(uint8_t byte)  
{ 
 if ((byte&0x01)==0) { SendBitInform(0);  }  else { SendBitInform(1); }  
 }
 
 
void Sendnbits_nInform_0If_nthBit_is1( uint 8_t byte, uint 8_t Addr, uint8_t num ) 
uint8_t count =0;  
LabelNextByte:
SetPinsDefault1();
SetAddrInform() ;
SetPin34Out();
if((byte&0x01)==0) { SetPin34High() ;  } else  {  SetPin34Low();}
SendStrobeSync(Addr); 
count++;
if (count<num) {  byte=(byte>>1);  goto LabelNextByte ;}
return;
}
 
void Sendnbits_nInform_1If_nthBitis1( uint 8_t byte, uint 8_t Addr, uint8_t num ) 
uint8_t count =0;  
LabelNextByte:
SetPinsDefault1();
SetAddrInform() ;
SetPin34Out();
if((byte&0x01)!=0) { SetPin34High() ;  } else  {  SetPin34Low();}
SendStrobeSync(Addr); 
count++;
if (count<num) {  byte=(byte>>1);  goto LabelNextByte ;}
return;
}
 
/*************************************/
 
void  SendDivCoefDVDC( uint8_t digits[6]) 
 {
 /*
; for bit=1 in the register set 0  on the pin34 as output , 1-st bit of the LSB digit of the dividing coeff.  first 
;  bit 0  digit1  , LSB  Send_nInformBit_0_IfFirtstBitTrue 
;  bit 1  digit1
;  bit 2  digit1
;  bit 3  digit1
;  bit 0  digit2  digits_f[1];  , for D26
;  bit 1  digit2
;  bit 2  digit2
;  bit 3  digit2
;  bit 0  digit3  digits_f[2];  , for D7
;  bit 1  digit3
;  bit 2  digit3
;  bit 3  digit3
;  bit 0  digit4   ;  digits_f[3];//9, for D10
;  bit 1  digit4
;  bit 2  digit4
;  bit 3  digit4
;  bit 0  digit5   digits_f[4];//7,for D16
;  bit 1  digit5
;  bit 2  digit5
;  bit 3  digit5
;  bit 0  digit6   ; digits_f[5];//12, for D20
;  bit 1  digit6
;  bit 2  digit6
;  bit 3  digit6
 
; mov reg_data, reg_byte0 ; digits_f[0];   8, for D24
*/
 
 
Sendnbits_nInform_0If_nthBit_is1(digits[0], ADDR_DPKD, 0x04);
Sendnbits_nInform_0If_nthBit_is1(digits[1], ADDR_DPKD, 0x04);
Sendnbits_nInform_0If_nthBit_is1(digits[2], ADDR_DPKD, 0x04);
Sendnbits_nInform_0If_nthBit_is1(digits[3], ADDR_DPKD, 0x04);
Sendnbits_nInform_0If_nthBit_is1(digits[4], ADDR_DPKD, 0x04);
Sendnbits_nInform_0If_nthBit_is1(digits[5], ADDR_DPKD, 0x04); 
    
//SendMemWrPulse(); 
}
 
 
 
void SendDAC_FM_DAC(uint8_t DACFM, uint8_t DACAt   ){
 /*
; for send 1  to the trigger FM/At  set 0   on the pin 34 and send SyncFM pulse 
 
 ; bit '8' DAC at, no data
 ; bit '4' DAC at
 ; bit '2' DAC at
 ; bit '1' DAC at 
 
; bit 2 DAC FM 
; bit 3 DAC FM
; bit 4 DAC FM 
; bit 5 DAC FM 
; bit 6 DAC FM  
; bit 7 DAC FM
; bit 8 DAC FM
; bit 9 DAC FM  
*/
//;    db1=DACAt,  LSB bit '8' DACAt  ;   
  Sendnbits_nInform_0If_nthBit_is1( DACAt, ADDR_FM, 0x04);
//; send DAC FM coefs , bit '2' DAC FM
  Sendnbits_nInform_0If_nthBit_is1(DAC FM, ADDR_FM, 0x08);
// ;  12 pulses 
 
}
 
 
 
 
void  SendModeBits(uint8_t BitsOut, uint8_t BitsModul, uint8_t  BitsLFO){
/*
 ;   BitsOut reg_byte0 ,  BitsModul reg_byte1 ,  BitsLFO reg_byte2
 ;  24 bit data
 ; 8   no      LSB
 ; 4   no
 ; 2   no
 ;  1 Out 
 ;  8 +6dB
 ;  4 uV
 ;  2 mV
 ;  1 dBV
 
 ;   no LSB
 ;   no
 ;   PM ext
 ;  AM ext
;  FM ext
 ;  PM
;   AM
;   FM
 
 ;  10k LSB   reg_byte2  BitsLFO
 ;  3,4k
 ;  2,5k
 ;  1k
;   0,4k
;   0,3k
;   0,2k
;   0,05k 
*/
 
  Sendnbits_nInform_0If_nthBit_is1( BitsOut, ADDR_MODE, 0x08);
  Sendnbits_nInform_0If_nthBit_is1( BitsModul, ADDR_MODE, 0x08);
  Sendnbits_nInform_0If_nthBit_is1 (BitsLFO, ADDR_MODE, 0x08);
 
}
 
void   SendDAC_AM_VRefCoefs(uint8_t DACVref[2],  uint8_t DACAM[2] ) 
{ 
//  ; DACVref reg_byte1, reg_byte0 ,  DACAM   reg_byte3,reg_byte2 
 /*
; for send 0  to the trigger AM/Vref  set 1   on the pin 34 and send SyncAM pulse 
;send DAC Vref 0...9 coefs , 1000= 0x03e8=0b 0000 0011 1110 1000 
 ; db1=DACVref ; 
 
;   bit 0 DAC VRef, reg_byte0,  LSB 
;   bit 1 DAC VRef  
;   bit 2 DAC VRef 
;   bit 3 DAC VRef
;   bit 4 DAC VRef 
;   bit 5 DAC VRef 
;   bit 6 DAC VRef  
;   bit 7 DAC VRef  
 
;   bit 8 DAC VRef reg_byte1, LSB
;   bit 9 DAC VRef 
 
 ;  bit 0 DAC AM , reg_byte2, LSB
 ;  bit 1 DAC AM
 ;  bit 2 DAC AM
 ;  bit 3 DAC AM
 ;  bit 4 DAC AM
 ;  bit 5 DAC AM
 ;  bit 6 DAC AM
 ;  bit 7 DAC AM
 
 ;  bit 8 DAC AM reg_byte3, LSB
 ;  bit 9 DAC AM
*/
 
Sendnbits_nInform_0If_nthBit_is1(DACVref[0], ADDR_AM_VREF, 0x08);
Sendnbits_nInform_0If_nthBit_is1(DACVref[1], ADDR_AM_VREF, 0x02);
 
//;send DAC AM coeffs 0...9
//; send DAC Vref 0...9 coefs 
Sendnbits_nInform_0If_nthBit_is1(DACAM[0], ADDR_AM_VREF, 0x08);
Sendnbits_nInform_0If_nthBit_is1(DACAM[1], ADDR_AM_VREF, 0x02);
 
// ;  20 pulses StrobeSyncAM 
}
 
 
void SendLFOBits( uint8_t LFObits, uint8_t LFOenabled) 
{
/* 
;  0  bit nE   reg_byte1 LFOenabled;  
;  1  bit '1' LFO reg_byte0 LFObits;  
;  2  bit '2' LFO
;  3  bit '4'   LFO
*/
Sendnbits_nInform_0If_nthBit_is1(LFOenabled, ADDR_LFO, 0x01);
Sendnbits_nInform_0If_nthBit_is1(LFObits, ADDR_LFO, 0x03);
//; SendMemWrPulse();
}
 
 
 
 
void  SendHFObits(uint8_t OscCode, uint8_t FMAtt)
{
/* 
; FMAtt reg_byte0 ,   OscCode  reg_byte1
 
;    FM Att 1/10     reg_byte0 ,LSB 
 
 ;     OSCSEL '1'   reg_byte1 ,LSB 
;      OSCSEL '2'
;      OSCSEL '4'
 ;     FilterBand
 ;     BandSel '1' 
;     BandSel '2'
;     BandSel '4'
*/
 
Sendnbits_nInform_0If_nthBit_is1(   FMAtt,  ADDR_HFO, 0x01);
Sendnbits_nInform_0If_nthBit_is1(  OscCode, ADDR_HFO, 0x07);
 
}
 
 
 
 
/***************************************/
 
 uint8_t SelectAtt2(uint8_t value , uint8_t *Flag10dB)
 {
/*
 ;0 means yoke off (  for 1 on the inform bus, 0 on the nInform  pin  )
 ;1 means yoke on  (  for 0 on the inform bus, 1 on the nInform  pin  )
 
*/      
if(value==0)   { *Flag10dB=0;  return  0b11110000; }    // 0 dB, 1000...317, DAC Vref decoder off
if(value==1)  { *Flag10dB=1;   return  0b11100001; } //10 dB, 999...319 , DAC Vref decoder on
if(value==2) {   *Flag10dB=0;  return  0b11010010; }//20 dB
if(value==3) {  *Flag10dB=1;  return  0b11000011; }//30 dB  
if(value==4) {  *Flag10dB=0;  return  0b10110100; }//40dB
if(value==5) {  *Flag10dB=1;   return  0b10100101; }//50dB
if(value==6) {  *Flag10dB=0;   return  0b10010110; }//60dB
if(value==7) {  *Flag10dB=1;    return  0b10000111; }//70dB
if(value==8) {  *Flag10dB=0;    return  0b01111000; }//80dB
if(value==9) {  *Flag10dB=1;    return  0b01101001; }//90dB
if(value==10) {  *Flag10dB=0;  return  0b01011010; }//100dB
if(value==11) {  *Flag10dB=1;  return  0b01001011; }//110dB          
if(value==12) {  *Flag10dB=0; return  0b00111100; }//120dB               
if(value==13) {  *Flag10dB=1; return  0b00101101; }//130dB                
if(value==14) {  *Flag10dB=0; return  0b00011110; }//140dB 
return 0;   
 }
 
 
void  SendAttBits(uint8 _t natt_data ,  uint8_t FlagOff )  
{
 /*
 ; uint8_t db1;
 ;db1=bits_att;
 ;0 means yoke off (  for 1 on the inform bus )
;1 means yoke on  (  for 0 on the inform bus )
; 0    10dB
; 1    20 dB
; 2    40 dB
; 3    80 dB
; 4    10 dB off
; 5    20 dB off
; 6    40 dB off
; 7    80 dB off 
*/
 
if(FlagOff==1){ natt_data=0x00;    }
Sendnbits_nInform_1If_nthBitis1( natt_data, ADDR_ATT, 0x08);
}
 
void  SendStaticCMDBits() ; StaticCMD 
{
/*
;
; uint8_t db1;
; for 0 on the trigger out (for not inverted outputs) send 0 via the inform bus
; for 1 on the trigger out (for not inverted outputs) set 1 via the inform bus
; for 1 on the trigger out  for   inverted outputs AMext,FMext,PMext  send 0 via the inform bus
; for 0 on the trigger out  for   inverted outputs  AMext,FMext,PMext send 1  via the inform bus
; nPMext ; nFMext ; nAMext ; PM; FM; AM; MixOn; 1kHz 
; db1=StaticCMD ;
1 0 ;   1 kHz
2 1 ;    MixOn 
3 2 ;   AM 
4 3 ;    FM  
5 4 ; PM
6 5 ; notAMext, see inverse output of the trigger D16
7 6 ;  notFMext, see inverse output of the trigger D16
8 7 ;  notPMext, see inverse output of the trigger D16
*/
 
Sendnbits_nInform_0If_nthBit_is1(  reg_byte0, ADDR_SYNCSTATIC, 0x08);
 //;SendMemWrPulse();
}
 
 /******************************************/
 
//in the  PROGMEM
uint8_t IndTableInvCode[16]  =
{
 0b10001000 , 0b11101101,0b10010100,0b10000101,0b10100001,0b10000011,0b10000010, 0b10101101,0b10000000, 0b10000001 ,
 0b1111011, 0b11111111 ,0b11111111,0b11111111,0b11111111,0b11111111
};
 
uint8_t  SevenSegment( uint8_t Digit, uint8_t Comma )  
{
/*
;
;LSB  e; c; b; d; f; g; a; h  MSB
;     a 
;b        c
;     d
;e        f
;     g
;              h
;1 on the inform bus means turn on segment
;                                          ecbdfga; 
; 
*/
 
uint8_t tmp= IndTableInvCode[Digit];
if(Comma!=0) {  return (IndTableInvCode[Digit]&0b01111111);        } //h  
 return (uint8_t) IndTableInvCode[(uint8_t)Digit];
}
 
 
 
void  SendBitsBlink( uint8_t BitsAddrBlink)    
 {
/*
; first sent bit 3  2   1  0 last sent bit 
; for 1 on the inform bus send 0 to pin 34 ( and send strobe after it )
*/
Send_nInformBit_1_IfByteFalse( (BitsAddrBlink&0x08)   ) ;
SendStrobeSync(ADDR_SYNCBLINK );
Send_nInformBit_1_IfByteFalse( (BitsAddrBlink&0x04)   ) ;
SendStrobeSync(ADDR_SYNCBLINK );
Send_nInformBit_1_IfByteFalse( (BitsAddrBlink&0x02)   ) ;
SendStrobeSync(ADDR_SYNCBLINK );
Send_nInformBit_1_IfByteFalse( (BitsAddrBlink&0x01)   ) ;
SendStrobeSync(ADDR_SYNCBLINK );
//; without SyncWRRAM pulse , use after send all digits for blink control with TurnOnBlink(),TurnOffBlink(); 
}
 
 
 
void SendBitsRAM(uint8_t BitsAddr, uint8_t Digit , uint8_t BitComma/*,  uint8_t BitsBlink*/)
{ 
/*
;
;     a 
;b        c
;     d
;e        f
;     g
 ;             h
;1 on the inform bus means turn on segment
;
;Inform n8; n4; n2 ; n1 ; e; c; b; d; f; g; a; h;
;
;
;0 1 2 3 4 5 6      7 8 9         a b      c d e f      Addr
;f  e d c b  a 9      8 7 6        5 4      3 2 1 0   ~Addr
;x x x x x x x      x x x         x x      x x x x ;
; Digit  reg_byte0 ,   Comma reg_byte1
; send address bit using inverse code  
;  for set 1 on the bit Inform set 0 on the nInform (for pin 34 emulation )   
; for set 0 on the bit Inform set 1 on the nInform (for pin 34 emulation )    
*/
uint8_t byte= SevenSegment() ;  
Send_nInformBit_1_IfByteFalse( (BitsAddrBlink&0x08)   ) ;  //  addr 8 
SendStrobeSync(ADDR_SYNCRAM ); //1
Send_nInformBit_1_IfByteFalse( (BitsAddrBlink&0x04)   ) ;  //  addr 4   
SendStrobeSync(ADDR_SYNCRAM ); //2 
Send_nInformBit_1_IfByteFalse( (BitsAddrBlink&0x02)   ) ;  //  addr 2   
SendStrobeSync(ADDR_SYNCRAM ); //3  
Send_nInformBit_1_IfByteFalse( (BitsAddrBlink&0x01)   ) ;  //  addr 1   
SendStrobeSync(ADDR_SYNCRAM ); //4   
 
 
/* for turn on segment set 1  on the Inform Bus, set nIform(34)=0,  as the output */
Sendnbits_nInform_0If_nthBit_is1( byte, ADDR_SYNCRAM , 0x08);
SendMemWrRAMPulse() ; 
 
 
/*
0 e LSB
1 c
2 b 
3 d
4 f
5 g
6 a
7 h
 
*/
 
 
 
 
 
return;
}
 
 
  
/****************************************************/
 
 
 
 
uint8_t  GetByteLD()
{
//; nLD0 ,nLD1,nLD2,nLD3,nLD4,nLD4,nLD5,nLD6, 1 
SetPin34Input() ;  
 
uint8_t reg_data=0; 
for (uint8_t  count=0; count<8; i++)
{
SendPulseSyncInLD() ; //   Pin36 to multiplexer , Sync 
 SetPin34Input() ; 
if ( GetBitInformLD()==0 ) { reg_data|=(1<<count);  }   // decode for true bits  
}
 
reg_data&=0x7F;    
//; call SendPulse_data_accept;   
return reg_data;
}
 
 
 
 
uint8_t  GetByteGCd()
{
/*
;7 6  5  4    3     2     1    0 
;x;x;x;nc1;nr1;nr2;nc0;nr0;   
*/
SetPin34Input() ;  
 
uint8_t reg_data=0; 
for (uint8_t count=0; count<8; i++)
{
 SendPulseSyncInGCD() ; //   Pin36 to multiplexer , SyncPool
 SetPin34Input() ; 
if ( GetBitInformGCd()!=0 ) { reg_data|=(1<<count);  }  
}
 
//; call SendPulse_data_accept;  optimize plce of this subroutine 
return reg_data;
}

#define GetHBYTE (  WORD ) (  (uint8_t) (((WORD)&0xff00)>>8)   )
#define GetLBYTE (  WORD ) (  (uint8_t) (((WORD)&0x00ff)>>0)   )
 
 
//read  using uint16_t word=pgm_read_word_near(LogTable1 + k); k= minusdbV*10
const uint16_t  LogTable1[100]   PROGMEM 
{
  0x03e8,  0x03dd,  0x03d1,  0x03c6,  0x03bb,  0x03b0,  0x03a5,  0x039b,  0x0390,  0x0386 ,  /* 0.0-0.9   */
 0x037b,  0x0371,  0x0367,  0x035d,  0x0353,  0x0349,  0x0340,  0x0336,  0x032d,  0x0324 ,   /* 1.0-1.9   */
 0x031a,  0x0311,  0x0308,  0x02ff,  0x02f7,  0x02ee,  0x02e5,  0x02dd,  0x02d4,  0x02cc ,      /* 2.0-2.9   */
  0x02c4,  0x02bc,  0x02b4,  0x02ac,  0x02a4,  0x029c,  0x0295,  0x028d,  0x0286,  0x027e,   /* 3.0-3.9   */
  0x0277,  0x0270,  0x0269,  0x0262,  0x025b,  0x0254,  0x024d,  0x0246,  0x023f,  0x0239 ,  /* 4.0-4.9   */
  0x0232,  0x022c,  0x0226,  0x021f,  0x0219,  0x0213,  0x020d,  0x0207,  0x0201,  0x01fb ,    /* 5.0-5.9   */
  0x01f5,  0x01ef,  0x01ea,  0x01e4,  0x01df,  0x01d9,  0x01d4,  0x01ce,  0x01c9,  0x01c4 ,      /* 6.0-6.9   */
  0x01bf,  0x01ba,  0x01b5,  0x01b0,  0x01ab,  0x01a6,  0x01a1,  0x019c,  0x0197,  0x0193,     /* 7.0-7.9   */
  0x018e,  0x018a,  0x0185,  0x0181,  0x017c,  0x0178,  0x0174,  0x016f,  0x016b,  0x0167 ,   /* 8.0-8.9   */
  0x0163,  0x015f,  0x015b,  0x0157,  0x0153,  0x014f,  0x014b,  0x0147,  0x0144,  0x0140     /* 9.0-9.9   */
} ;
 
//read  using uint16_t word=pgm_read_word_near(LinTable316 + k);   k=316-u
const uint16_t LinTable316[216] PROGMEM
{
 0x03e7,  0x03e4,  0x03e1,  0x03de,  0x03db,  0x03d8,  0x03d4,  0x03d1,  0x03ce,  0x03cb,  /* 0-9   ,  316,315...307*/
 0x03c8,  0x03c5,  0x03c1,  0x03be,  0x03bb,  0x03b8,  0x03b5,  0x03b2,  0x03ae,  0x03ab , /* 10-19,  306,305...297 */
 0x03a8,  0x03a5,  0x03a2,  0x039f,  0x039b,  0x0398,  0x0395,  0x0392,  0x038f,  0x038c,   /* 20-29 ,  296,295...287*/
 0x0388,  0x0385,  0x0382,  0x037f,  0x037c,  0x0379,  0x0376,  0x0372,  0x036f,  0x036c, /* 30-39,  286,285...277 */
 0x0369,  0x0366,  0x0363,  0x035f,  0x035c,  0x0359,  0x0356,  0x0353,  0x0350,  0x034c, /* 40-49,  276,275...267 */
 0x0349,  0x0346,  0x0343,  0x0340,  0x033d,  0x0339,  0x0336,  0x0333,  0x0330,  0x032d, /* 50-59,  266,265...257 */
 0x032a,  0x0326,  0x0323,  0x0320,  0x031d,  0x031a,  0x0317,  0x0313,  0x0310,  0x030d ,/* 60-69 ,  256,255...247*/
 0x030a,  0x0307,  0x0304,  0x0301,  0x02fd,  0x02fa,  0x02f7,  0x02f4,  0x02f1,  0x02ee, /* 70-79 ,  246,245...237*/
 0x02ea,  0x02e7,  0x02e4,  0x02e1,  0x02de,  0x02db,  0x02d7,  0x02d4,  0x02d1,  0x02ce, /* 80-89,  236,235...227 */
 0x02cb,  0x02c8,  0x02c4,  0x02c1,  0x02be,  0x02bb,  0x02b8,  0x02b5,  0x02b1,  0x02ae, /* 90-99 ,  226,225...217*/
 
 0x02ab,  0x02a8,  0x02a5,  0x02a2,  0x029e,  0x029b,  0x0298,  0x0295,  0x0292,  0x028f , /* 100-109,  216,215...207 */
 0x028b,  0x0288,  0x0285,  0x0282,  0x027f,  0x027c,  0x0279,  0x0275,  0x0272,  0x026f , /* 110-119 ,  206,205...197 */
 0x026c,  0x0269,  0x0266,  0x0262,  0x025f,  0x025c,  0x0259,  0x0256,  0x0253,  0x024f , /* 120-129 ,  196,195...187 */
 0x024c,  0x0249,  0x0246,  0x0243,  0x0240,  0x023c,  0x0239,  0x0236,  0x0233,  0x0230 , /* 130-139 ,  186,185...177 */
 0x022d,  0x0229,  0x0226,  0x0223,  0x0220,  0x021d,  0x021a,  0x0216,  0x0213,  0x0210 , /* 140-149 ,  176,175...167 */
 0x020d,  0x020a,  0x0207,  0x0203,  0x0200,  0x01fd,  0x01fa,  0x01f7,  0x01f4,  0x01f1 ,      /* 150-159,  166,165...157  */
 0x01ed,  0x01ea,  0x01e7,  0x01e4,  0x01e1,  0x01de,  0x01da,  0x01d7,  0x01d4,  0x01d1 , /* 160-169,  156,155...147  */
 0x01ce,  0x01cb,  0x01c7,  0x01c4,  0x01c1,  0x01be,  0x01bb,  0x01b8,  0x01b4,  0x01b1, /* 170-179,  146,145...137  */
 0x01ae,  0x01ab,  0x01a8,  0x01a5,  0x01a1,  0x019e,  0x019b,  0x0198,  0x0195,  0x0192, /* 180-189,  136,135...127  */
 0x018e,  0x018b,  0x0188,  0x0185,  0x0182,  0x017f,  0x017c,  0x0178,  0x0175,  0x0172, /* 190-199,  126,125...117 */
 
 0x016f,  0x016c,  0x0169,  0x0165,  0x0162,  0x015f,  0x015c,  0x0159,  0x0156,  0x0152 ,  /* 200-209 ,   116,115...107*/
 0x014f,  0x014c,  0x0149,  0x0146,  0x0143,  0x013f    /* 210-215 ,   106,105...101 */
};

#include <avr/pgmspace.h>
//uint8_t hbyte=pgm_read_byte_near(LogTableH + k);
const uint8_t  LogTableH[100]   PROGMEM 
{
  0x03,   0x03,  0x03,  0x03,   0x03,   0x03,  0x03,    0x03,   0x03,   0x03, 
 0x03,   0x03,  0x03,  0x03,   0x03,   0x03,   0x03,   0x03,   0x03,   0x03,  
 0x03,   0x03,   0x03,   0x02,   0x02,   0x02,   0x02,   0x02,   0x02,   0x02,  
  0x02,   0x02,  0x02,  0x02,   0x02,   0x02,   0x02,   0x02,  0x02,   0x02, 
  0x02,   0x02,   0x02,   0x02,  0x02,   0x02,    0x02,   0x02,   0x02,  0x02, 
  0x02,  0x02,   0x02,  0x02,   0x02,   0x02,  0x02,   0x02,  0x02,  0x01, 
  0x01,   0x01,   0x01,   0x01,   0x01,   0x01,   0x01,   0x01,   0x01,   0x01, 
  0x01,   0x01,  0x01,  0x01,   0x01,   0x01,   0x01,  0x01,   0x01,  0x01, 
  0x01,   0x01,    0x01,   0x01,  0x01,  0x01,   0x01,   0x01,  0x01,   0x01, 
  0x01,   0x01,   0x01,   0x01,   0x01,   0x01,  0x01,   0x01,   0x01,   0x01  
};
//uint8_t lbyte=pgm_read_byte_near(LogTableL + k);
const uint8_t  LogTableL[100]   PROGMEM 
{
  0xe8,   0xdd,   0xd1,   0xc6,   0xbb,   0xb0,   0xa5,   0x9b,   0x90,   0x86 ,
  0x7b,   0x71,   0x67,   0x5d,   0x53,   0x49,   0x40,   0x36,   0x2d,   0x24, 
  0x1a,   0x11,   0x08,   0xff,     0xf7,    0xee,   0xe5,   0xdd,   0xd4,   0xcc ,
   0xc4,  0xbc,   0xb4,   0xac,   0xa4,     0x9c,  0x95,   0x8d,   0x86,    0x7e ,
   0x77,   0x70,  0x69,   0x62,   0x5b,   0x54,   0x4d,   0x46,   0x3f,   0x39 ,
   0x32,   0x2c,   0x26,   0x1f,   0x19,   0x13,   0x0d,   0x07,   0x01,   0xfb, 
   0xf5,    0xef,   0xea,   0xe4,   0xdf,   0xd9,   0xd4,   0xce,   0xc9,   0xc4 ,
   0xbf,   0xba,   0xb5,   0xb0,   0xab,   0xa6,  0xa1,   0x9c,   0x97,   0x93 ,
   0x8e,   0x8a,   0x85,   0x81,   0x7c,   0x78,   0x74,   0x6f,   0x6b,   0x67 ,
   0x63,   0x5f,   0x5b,   0x57,   0x53,   0x4f,   0x4b,   0x47,   0x44,   0x40 
};

const uint16_t LinTable316H[216] PROGMEM
{
 0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  /* 0-9   ,  316,315...307*/
 0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03  , /* 10-19,  306,305...297 */
 0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,   /* 20-29 ,  296,295...287*/
 0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 , /* 30-39,  286,285...277 */
 0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 , /* 40-49,  276,275...267 */
 0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 , /* 50-59,  266,265...257 */
 0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x03  ,/* 60-69 ,  256,255...247*/
 0x03 ,  0x03 ,  0x03 ,  0x03 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 , /* 70-79 ,  246,245...237*/
 0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 , /* 80-89,  236,235...227 */
 0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 , /* 90-99 ,  226,225...217*/
 
 0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02  , /* 100-109,  216,215...207 */
 0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02  , /* 110-119 ,  206,205...197 */
 0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02  , /* 120-129 ,  196,195...187 */
 0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02  , /* 130-139 ,  186,185...177 */
 0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02  , /* 140-149 ,  176,175...167 */
 0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x02 ,  0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01  ,      /* 150-159,  166,165...157  */
 0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01  , /* 160-169,  156,155...147  */
 0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01 , /* 170-179,  146,145...137  */
 0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01 , /* 180-189,  136,135...127  */
 0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01 , /* 190-199,  126,125...117 */
 
 0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01  ,  /* 200-209 ,   116,115...107*/
 0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01 ,  0x01     /* 210-215 ,   106,105...101 */
}; 
 
const uint16_t LinTable316L[216] PROGMEM
{
 0xe7,  0xe4,  0xe1,  0xde,  0xdb,  0xd8,  0xd4,  0xd1,  0xce,  0xcb,  /* 0-9   ,  316,315...307*/
 0xc8,  0xc5,  0xc1,  0xbe,  0xbb,  0xb8,  0xb5,  0xb2,  0xae,  0xab , /* 10-19,  306,305...297 */
 0xa8,  0xa5,  0xa2,  0x9f,  0x9b,  0x98,  0x95,  0x92,  0x8f,  0x8c,   /* 20-29 ,  296,295...287*/
 0x88,  0x85,  0x82,  0x7f,  0x7c,  0x79,  0x76,  0x72,  0x6f,  0x6c, /* 30-39,  286,285...277 */
 0x69,  0x66,  0x63,  0x5f,  0x5c,  0x59,  0x56,  0x53,  0x50,  0x4c, /* 40-49,  276,275...267 */
 0x49,  0x46,  0x43,  0x40,  0x3d,  0x39,  0x36,  0x33,  0x30,  0x2d, /* 50-59,  266,265...257 */
 0x2a,  0x26,  0x23,  0x20,  0x1d,  0x1a,  0x17,  0x13,  0x10,  0x0d ,/* 60-69 ,  256,255...247*/
 0x0a,  0x07,  0x04,  0x01,  0xfd,  0xfa,  0xf7,  0xf4,  0xf1,  0xee, /* 70-79 ,  246,245...237*/
 0xea,  0xe7,  0xe4,  0xe1,  0xde,  0xdb,  0xd7,  0xd4,  0xd1,  0xce, /* 80-89,  236,235...227 */
 0xcb,  0xc8,  0xc4,  0xc1,  0xbe,  0xbb,  0xb8,  0xb5,  0xb1,  0xae, /* 90-99 ,  226,225...217*/
 
 0xab,  0xa8,  0xa5,  0xa2,  0x9e,  0x9b,  0x98,  0x95,  0x92,  0x8f , /* 100-109,  216,215...207 */
 0x8b,  0x88,  0x85,  0x82,  0x7f,  0x7c,  0x079,  0x75,  0x72,  0x6f , /* 110-119 ,  206,205...197 */
 0x6c,  0x69,  0x66,  0x62,  0x5f,  0x5c,  0x59,  0x56,  0x53,  0x4f , /* 120-129 ,  196,195...187 */
 0x4c,  0x49,  0x46,  0x43,  0x40,  0x3c,  0x39,  0x36,  0x33,  0x30 , /* 130-139 ,  186,185...177 */
 0x2d,  0x29,  0x26,  0x23,  0x20,  0x1d,  0x1a,  0x16,  0x13,  0x10 , /* 140-149 ,  176,175...167 */
 0x0d,  0x0a,  0x07,  0x03,  0x00,  0xfd,  0xfa,  0xf7,  0xf4,  0xf1 ,      /* 150-159,  166,165...157  */
 0xed,  0xea,  0xe7,  0xe4,  0xe1,  0xde,  0xda,  0xd7,  0xd4,  0xd1 , /* 160-169,  156,155...147  */
 0xce,  0xcb,  0xc7,  0xc4,  0xc1,  0xbe,  0xbb,  0xb8,  0xb4,  0xb1, /* 170-179,  146,145...137  */
 0xae,  0xab,  0xa8,  0xa5,  0xa1,  0x9e,  0x9b,  0x98,  0x95,  0x92, /* 180-189,  136,135...127  */
 0x8e,  0x8b,  0x88,  0x85,  0x82,  0x7f,  0x7c,  0x78,  0x75,  0x72, /* 190-199,  126,125...117 */
 
 0x6f,  0x6c,  0x69,  0x65,  0x62,  0x5f,  0x5c,  0x59,  0x56,  0x52 ,  /* 200-209 ,   116,115...107*/
 0x4f,  0x4c,  0x49,  0x46,  0x43,  0x3f    /* 210-215 ,   106,105...101 */
};

#define  nATT_0_dB ~(0b11110000)  // уточнить инверсию  и порядок битов 
#define  nATT_10_dB ~(0b11100001)
#define  nATT_20_dB ~(0b11010010)
#define  nATT_30_dB  ~(0b11000011)
#define  nATT_40_dB  ~(0b10110100)
#define  nATT_50_dB  ~(0b10100101)
#define  nATT_60_dB  ~(0b10010110)
#define  nATT_70_dB  ~(0b10000111)
#define  nATT_80_dB  ~(0b01111000)
#define  nATT_90_dB  ~(0b01101001)
#define  nATT_100_dB  ~(0b01011010)
#define  nATT_110_dB  ~(0b01001011)
#define  nATT_120_dB  ~(0b00111100)
#define  nATT_130_dB   ~(0b00101101)
#define  nATT_140_dB  ~(0b00011110)
 
uint16_t  GetDACValue_dBV( uint16_t Value_dBV    ,  uint8_t  *attcode      )
{
uint8_t AttNum;
  
if(Value_dBV>=0){   
if(Value_dBV<=99){
*attcode=nATT_0_dB;
return (uint16_t )    pgm_read_word_near(LogTable1 + (Value_dBV))  ;
 }}
 
if(Value_dBV>=100){
if(Value_dBV<=199){
 
*attcode=nATT_10_dB;
return (uint16_t )    pgm_read_word_near(LogTable1 + (Value_dBV-100))  ;
 }} 
if(Value_dBV>=200){
if(Value_dBV<=299){
 
*attcode=nATT_20_dB; 
return (uint16_t )    pgm_read_word_near(LogTable1 + (Value_dBV-200))  ; 
 }}
if(Value_dBV>=300){
if(Value_dBV<=399){
 
*attcode=nATT_30_dB; 
return (uint16_t )    pgm_read_word_near(LogTable1 + (Value_dBV-300))  ; 
 }}
 
if(Value_dBV>=400){
if(Value_dBV<=499){
 
*attcode=nATT_40_dB;
return (uint16_t )    pgm_read_word_near(LogTable1 + (Value_dBV-400))  ;  
 }}
 
if(Value_dBV>=500){
if(Value_dBV<=599){
 
*attcode=nATT_50_dB;
return (uint16_t )    pgm_read_word_near(LogTable1 + (Value_dBV-500))  ;  
 }}
 
if(Value_dBV>=600){
if(Value_dBV<=699){
 
*attcode=nATT_60_dB;
return (uint16_t )    pgm_read_word_near(LogTable1 + (Value_dBV-600))  ; 
 }}
 
if(Value_dBV>=700){
if(Value_dBV<=799){
 
*attcode=nATT_70_dB;
return (uint16_t )    pgm_read_word_near(LogTable1 + (Value_dBV-700))  ;  
 }}
 
if(Value_dBV>=800){
if(Value_dBV<=899){
 
*attcode=nATT_80_dB;
return (uint16_t )    pgm_read_word_near(LogTable1 + (Value_dBV-800))  ; 
 }}
if(Value_dBV>=900){
if(Value_dBV<=999){
 
*attcode=nATT_90_dB;
return (uint16_t )    pgm_read_word_near(LogTable1 + (Value_dBV-900))  ;  
 }}
 
if(Value_dBV>=1000){
if(Value_dBV<=1099){
 
*attcode=nATT_100_dB;
return (uint16_t )    pgm_read_word_near(LogTable1 + (Value_dBV-1000))  ;  
 }}
 
if(Value_dBV>=1100){
if(Value_dBV<=1199){
 
*attcode=nATT_110_dB;
return (uint16_t )    pgm_read_word_near(LogTable1 + (Value_dBV-1100))  ; 
 }}
 
 
if(Value_dBV>=1200){
if(Value_dBV<=1299){
 
*attcode=nATT_120_dB;
return (uint16_t )    pgm_read_word_near(LogTable1 + (Value_dBV-1200))  ; 
 }}
if(Value_dBV>=1300){
if(Value_dBV<=1399){
 
*attcode=nATT_130_dB;
return (uint16_t )    pgm_read_word_near(LogTable1 + (Value_dBV-1300))  ; 
 }}
 
if(Value_dBV>=1400){
if(Value_dBV<=1499){
 
*attcode=nATT_0_dB;
return (uint16_t )    pgm_read_word_near(LogTable1 + (Value_dBV-1400))  ; 
 }}
 
 
 
}
 
 
uint16_t  GetDACValue_mV( uint16_t Value_mV    , uint8_t commapos,  uint8_t  *attcode      )
{
uint8_t AttNum;
 
 
if(Value_mV>=317){      //1000. ...317. mV
if(Value_mV<=1000){
if(commapos==COMMA_4DIGIT){   *attcode=nATT_0_dB; }  //1000. ...317. mV
if(commapos==COMMA_3DIGIT){   *attcode=nATT_20_dB; }//100.0  ...31.7 mV
if(commapos==COMMA_2DIGIT){   *attcode=nATT_40_dB; }//10.00  ...3.17 mV
return (uint16_t )  Value_mV     ;
 }}
 
 if(Value_mV>=101){   //101. ...316. mV 
if(Value_mV<=316){
if(commapos==COMMA_4DIGIT){   *attcode=nATT_10_dB; } //316. ...101. mV
if(commapos==COMMA_3DIGIT){   *attcode=nATT_30_dB; } //31.6  ...10.1  mV
if(commapos==COMMA_2DIGIT){   *attcode=nATT_50_dB; } //3.16  ...1.01  mV
 
 
return (uint16_t ) pgm_read_word_near(LinTable316 +(uint16_t) (316-Value_mV) )      ;
 }}
 
return 0;  
}
 
 
 
 
uint16_t  GetDACValue_mkV( uint16_t Value_mkV    , uint8_t commapos,  uint8_t  *attcode      )
{
uint8_t AttNum;
 
 
if(Value_mkV>=317){      //1000. ...317. mkV
if(Value_mkV<=1000){
if(commapos==COMMA_4DIGIT){   *attcode=nATT_60_dB; }  //1000. ...317. uV
if(commapos==COMMA_3DIGIT){   *attcode=nATT_80_dB; }//100.0  ...31.7 uV
if(commapos==COMMA_2DIGIT){   *attcode=nATT_100_dB; }//10.00  ...3.17 uV
if(commapos==COMMA_1DIGIT){   *attcode=nATT_120_dB; }//1.000  ...0.317 uV 
return (uint16_t )  Value_mkV     ;
 }}
 
 if(Value_mkV>=101){   //101. ...316. mkV
if(Value_mkV<=316){
if(commapos==COMMA_4DIGIT){   *attcode=nATT_70_dB; } //316. ...101. uV
if(commapos==COMMA_3DIGIT){   *attcode=nATT_90_dB; } //31.6  ...10.1  uV
if(commapos==COMMA_2DIGIT){   *attcode=nATT_110_dB; } //3.16  ...1.01  uV
if(commapos==COMMA_1DIGIT){   *attcode=nATT_130_dB; }//0.316  ...0.101 uV  
return (uint16_t ) pgm_read_word_near(LinTable316 +(uint16_t)  (316-Value_mkV))      ;
 }}
 
if(Value_mkV>=32){   //0.100 ... 0.032 mkV
if(Value_mkV<=100){
if(commapos==COMMA_1DIGIT){   *attcode=nATT_140_dB; }//0.100  ...0.032 uV  
 
return (uint16_t )    (Value_mkV*10);   //fix for fast mul10
 }}
 
 
return 0;  
 
}
 
 
uint16_t GetDACValue ( uint8_t digits[4], uint8_t commapos,  uint8_t  *attcode , uint8_t mode    )
{
uint16_t  Value ;
Value=GetOutValueFromDigits(digits);  //0032...1000
if(mode==TOKEN_Out_dB)  {  return   GetDACValue_dBV(Value, attcode );  } 
if(mode==TOKEN_Out_mkV)  { return GetDACValue_mV( Value, commapos, attcode);   } 
if(mode==TOKEN_Out_mV)  {   return GetDACValue_mkV(  Value, commapos,attcode );  } 
return 0;
}

uint16_t GetDACAMValue ( uint8_t digits )
{
uint16_t AMValue=0;    // AMValue=(uint16_t) 10*M 
for(uint8_t i=0;i<digit[1];i++) { AMValue+=10;  }
for(uint8_t i=0;i<digit[0];i++) { AMValue+=100;  } 
return  AMValue;
}

uint32_t freq_fromdigits_div10( uint8_t freq[7])
{
uint32 result=0;
result+=(uint32) freq[1];
for(uint8_t i=0;i<freq[2];i++) { result+=10;  } 
for(uint8_t i=0;i<freq[3];i++) { result+=100;  } 
for(uint8_t i=0;i<freq[4];i++) { result+=1000;  }
for(uint8_t i=0;i<freq[5];i++) { result+=10000;  }
for(uint8_t i=0;i<freq[6];i++) { result+=100000;  }
 
}
 
 
uint32_t freq_fromdigits ( uint8_t freq[7])
{
uint32 result=0;
result+=(uint32) freq[0];
for(uint8_t i=0;i<freq[1];i++) { result+=10;  } 
for(uint8_t i=0;i<freq[2];i++) { result+=100;  } 
for(uint8_t i=0;i<freq[3];i++) { result+=1000;  }
for(uint8_t i=0;i<freq[4];i++) { result+=10000;  }
for(uint8_t i=0;i<freq[5];i++) { result+=100000;  } 
for(uint8_t i=0;i<freq[5];i++) { result+=1000000;  } 
}
 
 
uint8_t *GetDVDCDigitsFromUint32_t( uint32_t in)  //"uint24_t" 
{
 uint8_t digits[5];
    /*
    digits[0]=(uint8_t)(in/100000) ;  in=in%100000;     
    digits[1]=(uint8_t)(in/10000) ;  in=in%10000;  
    digits[2]=(uint8_t)(in/1000) ;  in=in%1000;
    digits[3]=(uint8_t)(in/100) ;  in=in%100;
    digits[4]=(uint8_t)(in/10) ;  in=in%10;
    digits[5]=(uint8_t) (in);
        */    
   digits[0]=(uint8_t) divmod(  in , 0x000186A0 /*100000*/ ,  &in );
   digits[1]=(uint8_t) divmod(  in , 0x00002710 /*10000*/,  &in );
   digits[2]=(uint8_t) divmod(  in , 0x000003e8 /*1000*/,  &in );
   digits[3]=(uint8_t) divmod(  in , 0x00000064 /*100*/,  &in );
   digits[4]=(uint8_t) divmod(  in , 0x0000000A /*10*/,  &in ); 
   digits[5]=(uint8_t) divmod(  in , 0x00000001 /* 1*/ ,  &in );   
     
     
return (uint8_t *) digits;  
}
 
 
uint8_t * GetCoeffDPKD(uint8_t freq[7] ,  uint8_t *compfreq)
{
 
 
/*  Kddpkd_num= freq*Kd/5)  for f= 1.25 kHz
 Kddpkd_num=freq*Kd/4  for f=1 kHz
*/
  
      
 uint32_t FreqValue= freq_fromdigits_div10(freq);
 if(FreqValue<=639999 ){               640 000...1 279 998‬
 if( FreqValue>=320000){
*compfreq=FREQ1_25kHz                                   
return (uint8_t *)  GetDVDCDigitsFromUint32_t(  (uint32_t)(FreqValue <<1)    ); //Kddpkd=  freq/5=(freq/10)  *2 ; 
}}
             
 
 
 if( FreqValue<=319999){
 if(FreqValue>=160000 ){               640 000...1 279 996‬
 *compfreq=FREQ1_25kHz                                   
return (uint8_t *)  GetDVDCDigitsFromUint32_t(  (uint32_t)(FreqValue <<2)    );  // Kddpkd=  (freq*2 /5);   =(freq/10)  *4 ; 
}}
 /* *************** */            
 FreqValue= freq_fromdigits (freq);
 if(FreqValue<=1599999 ){               
 if( FreqValue>=800000){
   *compfreq=FREQ1kHz                                      
return (uint8_t *)  GetDVDCDigitsFromUint32_t( FreqValue ); //Kddpkd=  freq ; 
}}
 
 if(FreqValue<=799999 ){               
 if( FreqValue>=400000){
   *compfreq=FREQ1kHz                                      
return (uint8_t *)  GetDVDCDigitsFromUint32_t( (uint32_t)(FreqValue<<1) );   //  Kddpkd=  freq*2 ;
}}
 
 if(FreqValue<=399999 ){               
 if( FreqValue>=200000){
   *compfreq=FREQ1kHz                                      
return (uint8_t *)  GetDVDCDigitsFromUint32_t( (uint32_t)(FreqValue<<2) );  // Kddpkd=  freq*4 ;
}}
 
 if(FreqValue<=199999 ){               
 if( FreqValue>=140000){
   *compfreq=FREQ1kHz                                      
return (uint8_t *)  GetDVDCDigitsFromUint32_t( (uint32_t)(FreqValue<<3) ); // Kddpkd=  freq*8 ;
}} 
/********************************** mixer on  *******************************/
 if(FreqValue<=139999 ){               
 if( FreqValue>=1000){
*compfreq=FREQ1kHz                                      
return (uint8_t *)  GetDVDCDigitsFromUint32_t( (uint32_t)(FreqValue+1000000 )); // Kddpkd=  freq ;
}} 
 
 return 0;
}

#include <stdio.h>
#include <stdint.h>
 
 
using namespace std; 
 
int main()
{
uint8_t byte1,byte2;
int data; 
scanf("%d",&data);
byte1=(uint8_t) data;  
scanf("%d",&data); 
byte2=(uint8_t) data;  
uint16_t byte=byte1*10+byte2;
 
 
 printf("\n %d", byte);  
 
uint16_t  byte3= (byte <<3)+ (byte <<1);  // y=x*8+x*2
printf("\n %d", byte3);
 
}

#include <stdio.h>
#include <stdint.h>
 
 
using namespace std; 
 
int main()
{
uint8_t byte1,byte2;
int data; 
scanf("%d",&data);
byte1=(uint8_t) data;  
scanf("%d",&data); 
byte2=(uint8_t) data;  
uint16_t byte=byte1*10+byte2;
 
 
 printf("\n %d", byte);  
 
uint16_t  byte3= (byte <<3)+ (byte <<1);  // y=x*8+x*2
printf("\n %d", byte3);
 
}

using namespace std; 
 
int main()
{
uint8_t byte1,byte2;
int data; 
scanf("%d",&data);
byte1=(uint8_t) data;  
scanf("%d",&data); 
byte2=(uint8_t) data;  
uint16_t byte=byte1*10+byte2;
 
 
 printf("\n %d", byte);  
 
 //mul10{
 
 //uint16_t  byte3= (byte <<3)+ (byte <<1);
  uint16_t byte3=(byte <<1);
  byte3+=(byte3 <<2);
//}
 
 
printf("\n %d", byte3);
 
}

#define lowbyte(x)   ( (uint8_t)((x) & 0xFF))
#define highbyte(x)   ( (uint8_t)(((x)>>8) & 0xFF))
#define pin_test_(pinreg, bit) ((pinreg) & (1 << (bit))) // test for pin in PORTn
#define bit_test(byte,bit) ((byte) & (1 << (bit))) // test for bit set
 
 
 
void   SendDAC_AM_VRefCoefs(uint16_t DACVref ,  uint16_t DACAM  ) 
{ 
//  ; DACVref reg_byte1, reg_byte0 ,  DACAM   reg_byte3,reg_byte2 
 /*
; for send 0  to the trigger AM/Vref  set 1   on the pin 34 and send SyncAM pulse 
;send DAC Vref 0...9 coefs , 1000= 0x03e8=0b 0000 0011 1110 1000 
 ; db1=DACVref ; 
 
;   bit 0 DAC VRef, reg_byte0,  LSB 
;   bit 1 DAC VRef  
;   bit 2 DAC VRef 
;   bit 3 DAC VRef
;   bit 4 DAC VRef 
;   bit 5 DAC VRef 
;   bit 6 DAC VRef  
;   bit 7 DAC VRef  
 
;   bit 8 DAC VRef reg_byte1, LSB
;   bit 9 DAC VRef 
 
 ;  bit 0 DAC AM , reg_byte2, LSB
 ;  bit 1 DAC AM
 ;  bit 2 DAC AM
 ;  bit 3 DAC AM
 ;  bit 4 DAC AM
 ;  bit 5 DAC AM
 ;  bit 6 DAC AM
 ;  bit 7 DAC AM
 
 ;  bit 8 DAC AM reg_byte3, LSB
 ;  bit 9 DAC AM
*/
 
Sendnbits_nInform_0If_nthBit_is1( lowbyte(DACVref), ADDR_AM_VREF, 0x08);
Sendnbits_nInform_0If_nthBit_is1( highbyte(DACVref), ADDR_AM_VREF, 0x02);
 
//;send DAC AM coeffs 0...9
//; send DAC Vref 0...9 coefs 
Sendnbits_nInform_0If_nthBit_is1( lowbyte(DACAM), ADDR_AM_VREF, 0x08);
Sendnbits_nInform_0If_nthBit_is1(highbyte(DACAM), ADDR_AM_VREF, 0x02);
 
// ;  20 pulses StrobeSyncAM 
}

//in the  PROGMEM
uint8_t IndTableInvCode[16]  =
{
 0b10001000 , 0b11101101,0b10010100,0b10000101,0b10100001,0b10000011,0b10000010, 0b10101101,0b10000000, 0b10000001 ,
 0b1111011, 0b11111111 ,0b11111111,0b11111111,0b11111111,0b11111111
};
 
uint8_t  SevenSegment( uint8_t Digit, uint8_t Comma )  
{
/*
;
;LSB  e; c; b; d; f; g; a; h  MSB
;     a 
;b        c
;     d
;e        f
;     g
;              h
;1 on the inform bus means turn on segment
;                                          ecbdfga; 
; 
*/
 
uint8_t tmp= IndTableInvCode[Digit];
if(Comma!=0) {  return (IndTableInvCode[Digit]&0b01111111);        } //h  
 return (uint8_t) IndTableInvCode[(uint8_t)Digit];
}
 
 
 
void  SendBitsBlink( uint8_t BitsAddrBlink)    
 {
/*
; first sent bit 3  2   1  0 last sent bit 
; for 1 on the inform bus send 0 to pin 34 ( and send strobe after it )
*/
Send_nInformBit_1_IfByteFalse(  bit_test(BitsAddrBlink,3)    ) ;
SendStrobeSync(ADDR_SYNCBLINK );
Send_nInformBit_1_IfByteFalse(  bit_test(BitsAddrBlink,2)    ) ;
SendStrobeSync(ADDR_SYNCBLINK );
Send_nInformBit_1_IfByteFalse(  bit_test(BitsAddrBlink,1)   ) ;
SendStrobeSync(ADDR_SYNCBLINK );
Send_nInformBit_1_IfByteFalse( bit_test(BitsAddrBlink,0)    ) ;
SendStrobeSync(ADDR_SYNCBLINK );
//; without SyncWRRAM pulse , use after send all digits for blink control with TurnOnBlink(),TurnOffBlink(); 
}
 
 
 
void SendBitsRAM(uint8_t BitsAddr, uint8_t Digit , uint8_t BitComma/*,  uint8_t BitsBlink*/)
{ 
/*
;
;     a 
;b        c
;     d
;e        f
;     g
 ;             h
;1 on the inform bus means turn on segment
;
;Inform n8; n4; n2 ; n1 ; e; c; b; d; f; g; a; h;
;
;
;0 1 2 3 4 5 6      7 8 9         a b      c d e f      Addr
;f  e d c b  a 9      8 7 6        5 4      3 2 1 0   ~Addr
;x x x x x x x      x x x         x x      x x x x ;
; Digit  reg_byte0 ,   Comma reg_byte1
; send address bit using inverse code  
;  for set 1 on the bit Inform set 0 on the nInform (for pin 34 emulation )   
; for set 0 on the bit Inform set 1 on the nInform (for pin 34 emulation )    
*/
uint8_t byte= SevenSegment() ;  
Send_nInformBit_1_IfByteFalse( bit_test(BitsAddr ,3)  ) ;  //  addr 8 
SendStrobeSync(ADDR_SYNCRAM ); //1
Send_nInformBit_1_IfByteFalse(  bit_test(BitsAddr ,2)    ) ;  //  addr 4   
SendStrobeSync(ADDR_SYNCRAM ); //2 
Send_nInformBit_1_IfByteFalse(  bit_test(BitsAddr ,1)    ) ;  //  addr 2   
SendStrobeSync(ADDR_SYNCRAM ); //3  
Send_nInformBit_1_IfByteFalse(  bit_test(BitsAddr ,0)    ) ;  //  addr 1   
SendStrobeSync(ADDR_SYNCRAM ); //4   
 
 
/* for turn on segment set 1  on the Inform Bus, set nIform(34)=0,  as the output */
Sendnbits_nInform_0If_nthBit_is1( byte, ADDR_SYNCRAM , 0x08);
SendMemWrRAMPulse() ; 
 
 
/*
0 e LSB
1 c
2 b 
3 d
4 f
5 g
6 a
7 h
 
*/
 
 
 
 
 
return;
}

//call before  check_digit 
 
 
 
 
 
void CheckComma(uint8_t byte , uint8_t  count, uint8_t *CommaSet, uint8_t *CommaPos    )
{
if ((byte==TOKEN_DOT)&&(*CommaSet!=1)   )//fix 
{
if (count==0) { digits[0]=0; }   //set zero before comma in the  firsf digit of stack 
*CommaPos= count;
*CommaSet=1;
return  ;  //commaPos= count , no comma enter after, without  counter increment 
}
 
return  ; //return  
}
 
// call if digit was entered
uint8_t AppendDigit(uint8_t byte ,uint8_t *count, ndigits   )  // ndigits  7 for freq , 3 for  FM,2 for AM, 4  for  Vout    
{
if (count<ndigits )
{
digits[count]=byte;  // from shared variables in the ram (7...8 digits max , first byte is  MSB ), temporary stack of digits  
*count+=1;
return 0 ;
}
else { return 1; } //flag stop , no digits more 
}
 
 
/*        may be in the sharedvals.h    with uint8_t digits[7]   , data before normalisation , counter of entered digits for normaliser and comma position  register */
uint8_t count=0; //reset if call new mode for invalidate data in the "stack" of the digits 
uint8_t CommaSet=0; //reset  if call new mode , no change  if '.'(or  token ',' from keyboard ) was entered , temporary variable 
uint8_t IfNumDigit(uint8_t byte , uint8_t ndigits, uint8_t *CommaPos, uint8_t *count)
{
CheckComma( byte , count, &CommaSet,  CommaPos);
return AppendDigit( byte ,count, ndigits   );
}

/*
 * Gccapp1.c
 *
 * Created: 20.03.2020 02:09:14
 * Author : USERPC01
 */ 
 
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <math.h>
#include "vrefparser.h"
 #define low_byte(x)   ( (uint8_t)(((x)>>0) & 0xFF))
 #define high_byte(x)   ( (uint8_t)(((x)>>8) & 0xFF))
 
int main(void)
{
     
       
      //uint8_t mode_out =TOKEN_Out_dB;
    //  uint8_t mode_out =TOKEN_Out_mV;
       uint8_t mode_out =TOKEN_Out_mkV;
      uint8_t digit[7];
      
     main1: 
       digit[0]=0x00;
      digit[1]=0x09;
       digit[2]=0x09;
        digit[3]=0x09;
        uint8_t commapos=COMMA_4DIGIT;
        uint8_t attcode;
        
        uint16_t Value=GetDACValue(  digit , commapos,  &attcode ,   mode_out);
        
        
        
        PORTA=attcode;
        PORTB=low_byte(Value);
        PORTC=high_byte(Value);
        
        
      while (1) 
    {
         
     goto main1;
     
    
 
    
    
    
   
   
    
     
        
        
    }
}