Loop not repeating in execution

Hi,

I have been trying to perform a sleep function in repeat using the void loop function. This is the code taken from the USB descriptor code from the USB Host shield library.

I am running a watch dog timer and printing something on the serial. However, once the descriptor functions have been called, there is statement while( 1 ). I am observing that nothing after this statement is being executed and the loop does not repeat itself for execution from the first statement that is Serial.println("\r\n--");

The serial print available in the ISR routine only comes on the serial monitor and there is nothing from the loop function. What can bee the issue. Is the while(1) stopping all the execution of the loop function.

Void Loop () { Serial.println("\r\n--"); Usb.Task(); Serial.println("\r\n--"); if( Usb.getUsbTaskState() == USB_STATE_RUNNING ) { //if (millis() >= next_time) //counter for sleep sleepIND=1; { Serial.println("\r\n--"); Usb.ForEachUsbDevice(&PrintAllDescriptors); Serial.println("\r\n--"); Usb.ForEachUsbDevice(&PrintAllAddresses);

while( 1 ); //stop } }

This is the code taken from the USB descriptor code from the USB Host shield library.

No, it isn't. The type, Void, does not exist. Post ALL of your code that ACTUALLY compiles.

#include <avr/sleep.h>
#include <stdint.h>
#include <avr/interrupt.h>
#include <avr/wdt.h>
#include <avrpins.h>
#include <max3421e.h>
#include <usbhost.h>
#include <usb_ch9.h>
#include <Usb.h>
#include <usbhub.h>
#include <avr/pgmspace.h>
#include <address.h>

#include "pgmstrings.h"




int sleepStatus = 0;// variable to store a request for sleep
int count = 0;                   // counter
int c=0;
int sleepIND=0;
ISR(WDT_vect)
{
  Serial.println("dude we have entered the routine");
  c=c+1;
}


USB     Usb;
//USBHub  Hub1(&Usb);
//USBHub  Hub2(&Usb);
//USBHub  Hub3(&Usb);
//USBHub  Hub4(&Usb);
//USBHub  Hub5(&Usb);
//USBHub  Hub6(&Usb);
//USBHub  Hub7(&Usb);

uint32_t next_time;

void PrintAllAddresses(UsbDevice *pdev)
{
    UsbDeviceAddress adr;
    adr.devAddress = pdev->address;
    Serial.print("\r\nAddr:");
    Serial.print(adr.devAddress, HEX);
    Serial.print("(");
    Serial.print(adr.bmHub, HEX);
    Serial.print(".");
    Serial.print(adr.bmParent, HEX);
    Serial.print(".");
    Serial.print(adr.bmAddress, HEX);
    Serial.println(")");
}

void PrintAddress(uint8_t addr)
{
    UsbDeviceAddress adr;
    adr.devAddress = addr;
    Serial.print("\r\nADDR:\t");
    Serial.println(adr.devAddress,HEX);
    Serial.print("DEV:\t");
    Serial.println(adr.bmAddress,HEX);
    Serial.print("PRNT:\t");
    Serial.println(adr.bmParent,HEX);
    Serial.print("HUB:\t");
    Serial.println(adr.bmHub,HEX);
}

void setup()
{
  Serial.begin( 115200 );
  Serial.println("Start");

  if (Usb.Init() == -1)
      Serial.println("OSC did not start.");
      
  delay( 200 );
  
  next_time = millis() + 10000;
  wdtSetup();
}

void sleepNow()         // here we put the arduino to sleep
{
   set_sleep_mode(SLEEP_MODE_PWR_DOWN);  
   sleep_enable();         
   sleep_mode();       
   sleep_disable();            
}


byte getdevdescr( byte addr, byte &num_conf );

void PrintDescriptors(uint8_t addr)
{
    uint8_t rcode = 0;
    byte num_conf = 0;
    
    rcode = getdevdescr( (byte)addr, num_conf );
    if( rcode ) 
    {
      printProgStr(Gen_Error_str);
      print_hex( rcode, 8 );
    }
    Serial.print("\r\n");
    
    for (int i=0; i<num_conf; i++)
    {
        rcode = getconfdescr( addr, i );                 // get configuration descriptor
        if( rcode ) 
        {
          printProgStr(Gen_Error_str);
          print_hex(rcode, 8);
        }
        Serial.println("\r\n");
    }
}

void PrintAllDescriptors(UsbDevice *pdev)
{
    Serial.println("\r\n");
    print_hex(pdev->address, 8);
    Serial.println("\r\n--");
    PrintDescriptors( pdev->address );
}

void loop()
{
  
  
    Serial.println("\r\n--");
    Usb.Task();
    Serial.println("\r\n--");
    if( Usb.getUsbTaskState() == USB_STATE_RUNNING )
  {  
    //if (millis() >= next_time)
    //counter for sleep 
    sleepIND=1;
    {
        Serial.println("\r\n--"); 
        Usb.ForEachUsbDevice(&PrintAllDescriptors);
  Serial.println("\r\n--");      
        Usb.ForEachUsbDevice(&PrintAllAddresses);
        
        while( 1 );   
        //stop
    }
  }
  
}
 
byte getdevdescr( byte addr, byte &num_conf )
{
  USB_DEVICE_DESCRIPTOR buf;
  byte rcode;
  rcode = Usb.getDevDescr( addr, 0, 0x12, ( uint8_t *)&buf );
  if( rcode ) {
    return( rcode );
  }
  printProgStr(Dev_Header_str);
  printProgStr(Dev_Length_str);
  print_hex( buf.bLength, 8 );
  printProgStr(Dev_Type_str);
  print_hex( buf.bDescriptorType, 8 );
  printProgStr(Dev_Version_str);
  print_hex( buf.bcdUSB, 16 );
  printProgStr(Dev_Class_str); 
  print_hex( buf.bDeviceClass, 8 );
  printProgStr(Dev_Subclass_str);
  print_hex( buf.bDeviceSubClass, 8 );
  printProgStr(Dev_Protocol_str);
  print_hex( buf.bDeviceProtocol, 8 );
  printProgStr(Dev_Pktsize_str);
  print_hex( buf.bMaxPacketSize0, 8 );
  printProgStr(Dev_Vendor_str);
  print_hex( buf.idVendor, 16 );
  printProgStr(Dev_Product_str);
  print_hex( buf.idProduct, 16 );
  printProgStr(Dev_Revision_str);
  print_hex( buf.bcdDevice, 16 );
  printProgStr(Dev_Mfg_str);
  print_hex( buf.iManufacturer, 8 );
  printProgStr(Dev_Prod_str);
  print_hex( buf.iProduct, 8 );
  printProgStr(Dev_Serial_str);
  print_hex( buf.iSerialNumber, 8 );
  printProgStr(Dev_Nconf_str);
  print_hex( buf.bNumConfigurations, 8 );
  num_conf = buf.bNumConfigurations;
  return( 0 );
}
 
void printhubdescr(uint8_t *descrptr, uint8_t addr)
{
    HubDescriptor  *pHub = (HubDescriptor*) descrptr;
    uint8_t        len = *((uint8_t*)descrptr);
    
    printProgStr(PSTR("\r\n\r\nHub Descriptor:\r\n"));
    printProgStr(PSTR("bDescLength:\t\t"));
    Serial.println(pHub->bDescLength, HEX);
    
    printProgStr(PSTR("bDescriptorType:\t"));
    Serial.println(pHub->bDescriptorType, HEX);
    
    printProgStr(PSTR("bNbrPorts:\t\t"));
    Serial.println(pHub->bNbrPorts, HEX);
    
    printProgStr(PSTR("LogPwrSwitchMode:\t"));
    Serial.println(pHub->LogPwrSwitchMode, BIN);
    
    printProgStr(PSTR("CompoundDevice:\t\t"));
    Serial.println(pHub->CompoundDevice, BIN);
    
    printProgStr(PSTR("OverCurrentProtectMode:\t"));
    Serial.println(pHub->OverCurrentProtectMode, BIN);
    
    printProgStr(PSTR("TTThinkTime:\t\t"));
    Serial.println(pHub->TTThinkTime, BIN);
    
    printProgStr(PSTR("PortIndicatorsSupported:"));
    Serial.println(pHub->PortIndicatorsSupported, BIN);
    
    printProgStr(PSTR("Reserved:\t\t"));
    Serial.println(pHub->Reserved, HEX);

    printProgStr(PSTR("bPwrOn2PwrGood:\t\t"));
    Serial.println(pHub->bPwrOn2PwrGood, HEX);
    
    printProgStr(PSTR("bHubContrCurrent:\t"));
    Serial.println(pHub->bHubContrCurrent, HEX);
    
    for (uint8_t i=7; i<len; i++)
        print_hex(descrptr[i], 8);

    //for (uint8_t i=1; i<=pHub->bNbrPorts; i++)
    //    PrintHubPortStatus(&Usb, addr, i, 1);
}

byte getconfdescr( byte addr, byte conf )
{
  uint8_t buf[ BUFSIZE ];
  uint8_t* buf_ptr = buf;
  byte rcode;
  byte descr_length;
  byte descr_type;
  unsigned int total_length;
  rcode = Usb.getConfDescr( addr, 0, 4, conf, buf );  //get total length
  LOBYTE( total_length ) = buf[ 2 ];
  HIBYTE( total_length ) = buf[ 3 ];
  if( total_length > 256 ) {    //check if total length is larger than buffer
    printProgStr(Conf_Trunc_str);
    total_length = 256;
  }
  rcode = Usb.getConfDescr( addr, 0, total_length, conf, buf ); //get the whole descriptor
  while( buf_ptr < buf + total_length ) {  //parsing descriptors
    descr_length = *( buf_ptr );
    descr_type = *( buf_ptr + 1 );
    switch( descr_type ) {
      case( USB_DESCRIPTOR_CONFIGURATION ):
        printconfdescr( buf_ptr );
        break;
      case( USB_DESCRIPTOR_INTERFACE ):
        printintfdescr( buf_ptr );
        break;
      case( USB_DESCRIPTOR_ENDPOINT ):
        printepdescr( buf_ptr );
        break;
      case 0x29:
        printhubdescr( buf_ptr, addr );
        break;
      default:
        printunkdescr( buf_ptr );
        break;
        }//switch( descr_type  
    buf_ptr = ( buf_ptr + descr_length );    //advance buffer pointer
  }//while( buf_ptr <=...
  return( 0 );
}

Moderator edit: Try it with tags next time, please.

/* prints hex numbers with leading zeroes */
// copyright, Peter H Anderson, Baltimore, MD, Nov, '07
// source: http://www.phanderson.com/arduino/arduino_display.html
void print_hex(int v, int num_places)
{
  int mask=0, n, num_nibbles, digit;
 
  for (n=1; n<=num_places; n++) {
    mask = (mask << 1) | 0x0001;
  }
  v = v & mask; // truncate v to specified number of places
 
  num_nibbles = num_places / 4;
  if ((num_places % 4) != 0) {
    ++num_nibbles;
  }
  do {
    digit = ((v >> (num_nibbles-1) * 4)) & 0x0f;
    Serial.print(digit, HEX);
  } 
  while(--num_nibbles);
}
/* function to print configuration descriptor */
void printconfdescr( uint8_t* descr_ptr )
{
 USB_CONFIGURATION_DESCRIPTOR* conf_ptr = ( USB_CONFIGURATION_DESCRIPTOR* )descr_ptr;
  printProgStr(Conf_Header_str);
  printProgStr(Conf_Totlen_str);
  print_hex( conf_ptr->wTotalLength, 16 );
  printProgStr(Conf_Nint_str);
  print_hex( conf_ptr->bNumInterfaces, 8 );
  printProgStr(Conf_Value_str);
  print_hex( conf_ptr->bConfigurationValue, 8 );
  printProgStr(Conf_String_str);
  print_hex( conf_ptr->iConfiguration, 8 );
  printProgStr(Conf_Attr_str);
  print_hex( conf_ptr->bmAttributes, 8 );
  printProgStr(Conf_Pwr_str);
  print_hex( conf_ptr->bMaxPower, 8 );
  return;
}
/* function to print interface descriptor */
void printintfdescr( uint8_t* descr_ptr )
{
 USB_INTERFACE_DESCRIPTOR* intf_ptr = ( USB_INTERFACE_DESCRIPTOR* )descr_ptr;
  printProgStr(Int_Header_str);
  printProgStr(Int_Number_str);
  print_hex( intf_ptr->bInterfaceNumber, 8 );
  printProgStr(Int_Alt_str);
  print_hex( intf_ptr->bAlternateSetting, 8 );
  printProgStr(Int_Endpoints_str);
  print_hex( intf_ptr->bNumEndpoints, 8 );
  printProgStr(Int_Class_str);
  print_hex( intf_ptr->bInterfaceClass, 8 );
  printProgStr(Int_Subclass_str);
  print_hex( intf_ptr->bInterfaceSubClass, 8 );
  printProgStr(Int_Protocol_str);
  print_hex( intf_ptr->bInterfaceProtocol, 8 );
  printProgStr(Int_String_str);
  print_hex( intf_ptr->iInterface, 8 );
  return;
}
/* function to print endpoint descriptor */
void printepdescr( uint8_t* descr_ptr )
{
 USB_ENDPOINT_DESCRIPTOR* ep_ptr = ( USB_ENDPOINT_DESCRIPTOR* )descr_ptr;
  printProgStr(End_Header_str);
  printProgStr(End_Address_str);
  print_hex( ep_ptr->bEndpointAddress, 8 );
  printProgStr(End_Attr_str);
  print_hex( ep_ptr->bmAttributes, 8 );
  printProgStr(End_Pktsize_str);
  print_hex( ep_ptr->wMaxPacketSize, 16 );
  printProgStr(End_Interval_str);
  print_hex( ep_ptr->bInterval, 8 );
  
  return;
}
/*function to print unknown descriptor */
void printunkdescr( uint8_t* descr_ptr )
{
  byte length = *descr_ptr;
  byte i;
  printProgStr(Unk_Header_str);
  printProgStr(Unk_Length_str);
  print_hex( *descr_ptr, 8 );
  printProgStr(Unk_Type_str);
  print_hex( *(descr_ptr + 1 ), 8 );
  printProgStr(Unk_Contents_str);
  descr_ptr += 2;
  for( i = 0; i < length; i++ ) {
    print_hex( *descr_ptr, 8 );
    descr_ptr++;
  }
}
 
 
/* Print a string from Program Memory directly to save RAM */
void printProgStr(const prog_char str[])
{
  char c;
  if(!str) return;
  while((c = pgm_read_byte(str++)))
    Serial.print(c);
}

void wdtSetup() {
  cli();
  MCUSR = 0;
  WDTCSR |= B00011000;
  WDTCSR = B01100001;
  sei();
}

Moderator edit: And again.

http://arduino.cc/forum/index.php/topic,97455.0.html See, in particular, section 6.

My apologies for not including the code format !

ISR(WDT_vect)
{
  Serial.println("dude we have entered the routine");
  c=c+1;
}

I'm sure you've heard stories about how serial data transmission is relatively slow, and that serial printing in an ISR is not a good idea. What makes you think that this admonition does not apply to you?

I just added those line to check for whether the main loop is printing lines or not. Rite now I excluded this line from the ISR and even then the main loop is not repeating and printing nothing !

P.S. I am sorry but I didnt know about the slowness of Serial data. I am by name and in reality a newbie on such things

Vik009: there is statement while( 1 ).

Not in the code you posted there isn't.

Vik009: Is the while(1) stopping all the execution of the loop function.

Yes. What did you expect it to do?

Void Loop ()
{
 ...
        while( 1 );   
        //stop

  }

You even put a comment there: "stop". It does what you expect it to do.

Thanks :) Actually I had taken this code from the USB Host shield.

BR, Vik

Ok, well going back to your original question, which I don't fully understand:

I have been trying to perform a sleep function in repeat using the void loop function.

The code you posted, after being prompted, does not show the loop function. Nor the setup function. So I can't say if you are putting the processor to sleep in an appropriate way or not.