sleep current for remote control

I am not sure which section to post this in, its a remote control for an 8 digit LED 7-seg display…

I have built many remotes and have low current while in sleep , but his one is insisting on drawing 60 microamps in sleep

Heres the circuit/schematic or whatever the local dialect is in your part of our planet :-

When the " send" button is pressed, the ISR takes it out of sleep mode, scans all commons of the BCD switches in turn, and stores the switch data, which it transmits twice.

The power for the transmitter module is taken from the PTT pin, as driven buy the VirtualWire library ( this works fine )

The it goes to sleep.

The PTT and DATA lines are low from the VW library, the " send " button takes no current from its pin2 pullup resistor until pressed.
The outputs to the commons of the BCD switches are all low.

The spare pin 15 is set as an output HIGH as recommended.

I see on Nick Gammons’ topic that he has ADCSRA =0; where I have ADCSRA &= ~(1 << ADEN); ???

Is the 328P-UP low power like the 328P ? The data sheet says less than 1 microamp.

Here is my ( tidy ) version of the sketch :-

//  battery operated ( 3 x AAA ) remote to send values of 8 dgits to a display board.
//   thumbwheel BCD swithes are scanned - outputs isolated by schottky diodes to 1,2,4,8 inputs of 328, with pull down 100k
// resisitors on each.
//ptt runs supply to transmitter
//  send button grounds ISR input pin 2 with pull up res.  transmits message twice and goes back to sleep

#include <VirtualWire.h>    // Wireless transmitter/receiver library
#include <avr/sleep.h>      // powerdown library
#include <avr/interrupt.h>  // interrupts library

uint8_t SW[4]; // assign four data pins from bcd switches
int SW0 = 5;               // bits to read from bcd switches LSB
int SW1 = 6;               
int SW2 = 7;               
int SW3 = 8;               //  MSB
int address = 0;          
int add0;  //  bits generated from BCD switches
int add1;
int add2;
int add3;
int comA = 13;   // switch scans to BCD switch commons
int comB = 12;
int comC = 11;
int comD = 10;
int comE = 19;
int comF = 18;
int comG = 16;
int comH = 17;
int sparepin = 14;
int PIN = 51;  //  preset pin number to send this one   = 51  ( CUSTOMERS UNDERSTAND "PIN NUMBER" BETTER THAN "UNIQUE ADDRESS" :-) )                          
int dataA;  //  data rebuilt from BCD binary
int dataB;
int dataC;
int dataD;
int dataE;
int dataF;
int dataG;
int dataH;
int pin2 = 2;               // Int0 interrupt pin
int sleep_count = 0;      // flag/counter to tell us to go sleep
char msg [9]; //   PIN number plus 8 digts
//***************************************************
void pin2Interrupt()
{
  /* This brings us back from sleep. */
}
//***************************************************

void enterSleep()
{
  digitalWrite(comA, LOW);    //  make sure all commons of BCD switches are low ( no current through pull down resistors )
  digitalWrite(comB, LOW);
  digitalWrite(comC, LOW);
  digitalWrite(comD, LOW);
  digitalWrite(comE, LOW);
  digitalWrite(comF, LOW);
  digitalWrite(comG, LOW);
  digitalWrite(comH, LOW);
   
  
  attachInterrupt(0, pin2Interrupt, FALLING);
  delay(50); // need this?
  set_sleep_mode(SLEEP_MODE_PWR_DOWN);  // setting up for sleep ...
  sleep_enable();                       // setting up for sleep ...
  ADCSRA &= ~(1 << ADEN);
  PRR = 0xFF;
  sleep_mode();                         // now goes to Sleep and waits for the interrupt
  /* The program will continue from here after the interrupt. */
  detachInterrupt(0);                 //disable interrupts while we get ready to read the keypad 
  PRR = 0x00;
  /* First thing to do is disable sleep. */
  sleep_disable(); 
}

void setup()
{
  Serial.begin(9600);
  pinMode(pin2, INPUT);                 // our sleep interrupt pin
  digitalWrite(pin2, HIGH);  // set pull up res
  pinMode (comA , OUTPUT );  // common slders of the BCD switches
  pinMode (comB , OUTPUT );
  pinMode (comC , OUTPUT );
  pinMode (comD , OUTPUT );
  pinMode (comE , OUTPUT );
  pinMode (comF , OUTPUT );
  pinMode (comG , OUTPUT );
  pinMode (comH , OUTPUT );
  pinMode ( sparepin, OUTPUT );  //  just in case its taking current in sleep ???
  digitalWrite(sparepin , HIGH);
  pinMode(SW0, INPUT); // LSB of bcd
  byte add0 = 0; 
  pinMode(SW1, INPUT); // LSB+1
  byte add1= 0;
  pinMode(SW2, INPUT);  // LSB+2
  byte add2 = 0;
  pinMode(SW3, INPUT);  // MSB of bcd
  byte add3 = 0;
;
  digitalWrite(SW0, LOW);   
  digitalWrite(SW1, LOW);
  digitalWrite(SW2, LOW);
  digitalWrite(SW3, LOW);

  
  vw_set_rx_pin(15);   //  needs this or pin 11 default vw pin( G ) doesnt go low !!!!  pin 15 IS spare
  vw_set_tx_pin(9);    //  Tx module connections 
  vw_set_ptt_pin(4); // powers Tx and LED if fitted 
  vw_setup(2000);
}                                          
// *************************************************************************end of void Setup()  

void loop()
{ 
  enterSleep(); 
  digitalWrite(comA, LOW);    //  just in case)
  digitalWrite(comB,LOW);
  digitalWrite(comC, LOW);
  digitalWrite(comD, LOW);
  digitalWrite(comE, LOW);
  digitalWrite(comF, LOW);
  digitalWrite(comG, LOW);
  digitalWrite(comH, LOW);
  //******************************  NOW TAKE EACH COM HIGH AND READ THE SWITCHES
  msg [0]  = PIN;
  //***********************************   
  digitalWrite(comA, HIGH);   
  address=0;  
  scan ();  
  msg [1]  = address;    
  digitalWrite(comA, LOW);       
  //***********************************   
  digitalWrite(comB, HIGH); 
  address=0;
  scan ();      
  msg [2]  = address;         
  digitalWrite(comB, LOW);      
  //***********************************   
  digitalWrite(comC, HIGH); 
  address=0;
  scan ();      
  msg [3]  = address;         
  digitalWrite(comC, LOW);        
  //***********************************   
  digitalWrite(comD, HIGH); 
  address=0;
  scan ();      
  msg [4]  = address;         
  digitalWrite(comD, LOW);        
  //***********************************   
  digitalWrite(comE, HIGH); 
  address=0;
  scan ();      
  msg [5]  = address;         
  digitalWrite(comE, LOW);        
  //***********************************   
  digitalWrite(comF, HIGH); 
  address=0;
  scan ();      
  msg [6]  = address;         
  digitalWrite(comF, LOW);     

  //***********************************   
  digitalWrite(comG, HIGH); 
  address=0;
  scan ();      
  msg [7]  = address;         
  digitalWrite(comG, LOW);        
  //***********************************   
  digitalWrite(comH, HIGH); 
  address=0;
  scan ();      
  msg [8]  = address;         
  digitalWrite(comH, LOW);    


  vw_send((uint8_t *)msg, 9);     // send the character out
  vw_wait_tx();                             // Wait until the whole message is gone
  delay (10); // leaves a slight gap between transmissions 
  vw_send((uint8_t *)msg, 9);     // send the character out
  vw_wait_tx();                             // Wait until the whole message is gone
  delay (50); 

} // end of void loop  

void scan ()  {
   add3 = digitalRead(SW3); 
   add3 = add3 << 3;
   add2 = digitalRead(SW2);
   add2 = add2 << 2;
   add1 = digitalRead(SW1);
   add1 = add1 << 1;
   add0 = digitalRead(SW0);
   address = address|add3;
   address = address|add2;
   address = address|add1;
   address = address|add0;
}