WRITEDELAY();
    EP8CFG = 0xE2;          // ep8 is valid BULK IN 512 double buffered
    WRITEDELAY();
    EP8FIFOCFG = 0x01;      // set EP8:  0x05=MANUAL, 0x09=AUTOIN
    
    WRITEDELAY();
    EP8AUTOINLENH = 0x02; // Auto-commit 512-byte packets
    WRITEDELAY();
    EP8AUTOINLENL = 0x00;

    // для отладки читаем один сектор не зависимо от команды SCSI
    sectorcount = 1;
    while (sectorcount--)
    {
    // ждем, когда EP8 будет FULL
    while( !( EP68FIFOFLGS & 0x10 ) );

    // firmware commits EP8 packet
    INPKTEND = 0x08;

    while( !( EP68FIFOFLGS & 0x10 ) );
    // skip пакет, т.к. это 20 байт ответа
    INPKTEND = 0x88;
        }
    }

#include "adl_global.h"
#include "generated.h"

#include "main.h"
#include "adl_traces.h"

s32 I2C_handle;

#define WRITE_BUFF_SIZE 4
u8 WBUFF[WRITE_BUFF_SIZE]={0x20,0x6C,0x3F,0x5D};

adl_busI2CSettings_t I2Cconf = {
        0xAA,            
        ADL_BUS_I2C_CLK_STD,    
        ADL_BUS_I2C_ADDR_7_BITS,    
        ADL_BUS_I2C_MASTER_MODE
};

adl_busAccess_t I2Caccess = {
        0x00,                         //general call
        0x00    
};

void main_task (void) {
    //subscribe to I2C bus service
    I2C_handle=adl_busSubscribe(ADL_BUS_ID_I2C, 1, &I2Cconf);
    TRACE((2, "Writing to the bus"));
    s32 resp = adl_busWrite(I2C_handle, &I2Caccess, WRITE_BUFF_SIZE, WBUFF);
    TRACE((2, "%d",resp));
}

struct GSM_Struct
{
    char Send[XX];
    unsigned int Timeout;
    char Receive[YY];
    unsigned char State[Z];
} GSM[NUMBER_OF_OPERATIONS];

#define USART_BAUDRATE 9600
#define BAUD_PRESCALE ((F_CPU/(USART_BAUDRATE * 16UL)) - 1)

int main (void)
{
cli();

lcd_init(LCD_DISP_ON);
lcd_puts("!LCD Test");
_delay_ms(1000);
lcd_clrscr();

UCSRB |= (1 << RXEN) | (1 << TXEN); // Turn on the transmission and reception circuitry
UCSRC |= (1 << URSEL) | (1 << UCSZ0) | (1 << UCSZ1); // Use 8-bit character sizes

UBRRL = BAUD_PRESCALE; // Load lower 8-bits of the baud rate value into the low byte of the UBRR register
UBRRH = (BAUD_PRESCALE >> 8); // Load upper 8-bits of the baud rate value into the high byte of the UBRR register

UCSRB = ((1<<TXEN)|(1<<RXEN) | (1<<RXCIE)); // Enable receiver and transmitter and receive complete interrupt
sei(); // Enable the Global Interrupt Enable flag so that interrupts can be processed

USART_Transmit("AT\r\n");

lcd_puts("!z"); //debug message
_delay_ms(1000);

USART_Transmit("AT+CSMINS?\r\n");
lcd_puts("!z"); //debug message

for (;;) {}
}

ISR(USART_RXC_vect)
{
char ReceivedByte;
ReceivedByte = UDR; // Fetch the recieved byte value into the variable "ByteReceived"

lcd_putc(ReceivedByte);

/*if(ReceivedByte=='O'||ReceivedByte=='o')
lcd_puts("(o)");
if(ReceivedByte=='K'||ReceivedByte=='k')
lcd_puts("(k)"); - и это писал, т.к. даже в кодировке LCD засомневался*/
}

USB_Descriptor_Device_t PROGMEM DeviceDescriptor =
{
    .Header                 = {.Size = sizeof(USB_Descriptor_Device_t), .Type = DTYPE_Device},
        
    .USBSpecification       = VERSION_BCD(01.10),
    .Class                  = 0xEF,
    .SubClass               = 0x02,
    .Protocol               = 0x01,
                
    .Endpoint0Size          = FIXED_CONTROL_ENDPOINT_SIZE,
        
    .VendorID               = 0x03EB,
    .ProductID              = 0x204D,
    .ReleaseNumber          = 0x0000,
        
    .ManufacturerStrIndex   = 0x01,
    .ProductStrIndex        = 0x02,
    .SerialNumStrIndex      = USE_INTERNAL_SERIAL,
        
    .NumberOfConfigurations = FIXED_NUM_CONFIGURATIONS
};

USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor =
{
    .Config =
        {
            .Header                 = {.Size = sizeof(USB_Descriptor_Configuration_Header_t), .Type = DTYPE_Configuration},

            .TotalConfigurationSize = sizeof(USB_Descriptor_Configuration_t),
            .TotalInterfaces        = 4,
                
            .ConfigurationNumber    = 1,
            .ConfigurationStrIndex  = NO_DESCRIPTOR,
                
            .ConfigAttributes       = (USB_CONFIG_ATTR_BUSPOWERED | USB_CONFIG_ATTR_SELFPOWERED),
            
            .MaxPowerConsumption    = USB_CONFIG_POWER_MA(100)
        },
//HID
         .HID1_GenericInterface =
        {
            .Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},

            .InterfaceNumber        = 0,
            .AlternateSetting       = 0x00,
            
            .TotalEndpoints         = 1,
                
            .Class                  = 0x03,
            .SubClass               = 0x00,
            .Protocol               = HID_NON_BOOT_PROTOCOL,
                
            .InterfaceStrIndex      = 0x03
        },

    .HID1_GenericHID =
        {
            .Header                 = {.Size = sizeof(USB_HID_Descriptor_t), .Type = DTYPE_HID},
                                    
            .HIDSpec                = VERSION_BCD(01.11),
            .CountryCode            = 0x00,
            .TotalReportDescriptors = 1,
            .HIDReportType          = DTYPE_Report,
            .HIDReportLength        = sizeof(GenericReport)
        },

    .HID1_ReportINEndpoint =
        {
            .Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
                                        
            .EndpointAddress        = (ENDPOINT_DESCRIPTOR_DIR_IN | GENERIC_IN_EPNUM),
            .Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
            .EndpointSize           = HID_EPSIZE,
            .PollingIntervalMS      = 0x0A
        },
//Keyboard
    .HID2_KeyboardInterface =
        {
            .Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},

            .InterfaceNumber        = 1,
            .AlternateSetting       = 0x00,
            
            .TotalEndpoints         = 1,
                
            .Class                  = 0x03,
            .SubClass               = 0x01,
            .Protocol               = HID_BOOT_KEYBOARD_PROTOCOL,
                
            .InterfaceStrIndex      = 0x04
        },

    .HID2_KeyboardHID =
        {  
            .Header                 = {.Size = sizeof(USB_HID_Descriptor_t), .Type = DTYPE_HID},
            
            .HIDSpec                = VERSION_BCD(01.11),
            .CountryCode            = 0x00,
            .TotalReportDescriptors = 1,
            .HIDReportType          = DTYPE_Report,
            .HIDReportLength        = sizeof(KeyboardReport)
        },
        
    .HID2_ReportINEndpoint =
        {
            .Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},

            .EndpointAddress        = (ENDPOINT_DESCRIPTOR_DIR_IN | KEYBOARD_IN_EPNUM),
            .Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
            .EndpointSize           = HID_EPSIZE,
            .PollingIntervalMS      = 0x0A
        },
//Microphone
    .Audio_ControlInterface_IAD =
        {    
            .Header                 = {.Size = sizeof(USB_Descriptor_Interface_Association_t), .Type = DTYPE_InterfaceAssociation},

            .FirstInterfaceIndex    = 2,
            .TotalInterfaces        = 2,

            .Class                  = 0x01,
            .SubClass               = 0x01,
            .Protocol               = 0x00,

            .IADStrIndex            = 0x06
        },

    .Audio_ControlInterface =
        {
            .Header                   = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},

            .InterfaceNumber          = 2,
            .AlternateSetting         = 0,
            
            .TotalEndpoints           = 0,

            .Class                    = 0x01,
            .SubClass                 = 0x01,
            .Protocol                 = 0x00,

            .InterfaceStrIndex        = 0x06
        },

    .Audio_ControlInterface_SPC =
        {
            .Header                   = {.Size = sizeof(USB_Audio_Interface_AC_t), .Type = DTYPE_AudioInterface},
            .Subtype                  = DSUBTYPE_Header,

            .ACSpecification          = VERSION_BCD(01.00),
            .TotalLength              = (sizeof(USB_Audio_Interface_AC_t) +
                                         sizeof(USB_Audio_InputTerminal_t) +
                                         sizeof(USB_Audio_OutputTerminal_t)),
            
            .InCollection             = 1,
            .InterfaceNumbers         = {1},
        },

    .Audio_InputTerminal =
        {
            .Header                   = {.Size = sizeof(USB_Audio_InputTerminal_t), .Type = DTYPE_AudioInterface},
            .Subtype                  = DSUBTYPE_InputTerminal,

            .TerminalID               = 0x01,
            .TerminalType             = TERMINAL_IN_MIC,
            .AssociatedOutputTerminal = 0x00,

            .TotalChannels            = 1,
            .ChannelConfig            = 0,

            .ChannelStrIndex          = NO_DESCRIPTOR,
            .TerminalStrIndex         = NO_DESCRIPTOR
        },

    .Audio_OutputTerminal =
        {
            .Header                   = {.Size = sizeof(USB_Audio_OutputTerminal_t), .Type = DTYPE_AudioInterface},
            .Subtype                  = DSUBTYPE_OutputTerminal,

            .TerminalID               = 0x02,
            .TerminalType             = TERMINAL_STREAMING,
            .AssociatedInputTerminal  = 0x00,

            .SourceID                 = 0x01,

            .TerminalStrIndex         = NO_DESCRIPTOR
        },

    .Audio_StreamInterface_Alt0 =
        {
            .Header                   = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},

            .InterfaceNumber          = 3,
            .AlternateSetting         = 0,

            .TotalEndpoints           = 0,

            .Class                    = 0x01,
            .SubClass                 = 0x02,
            .Protocol                 = 0x00,

            .InterfaceStrIndex        = NO_DESCRIPTOR
        },

    .Audio_StreamInterface_Alt1 =
        {
            .Header                   = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},

            .InterfaceNumber          = 3,
            .AlternateSetting         = 1,

            .TotalEndpoints           = 1,

            .Class                    = 0x01,
            .SubClass                 = 0x02,
            .Protocol                 = 0x00,

            .InterfaceStrIndex        = NO_DESCRIPTOR
        },

    .Audio_StreamInterface_SPC =
        {
            .Header                   = {.Size = sizeof(USB_Audio_Interface_AS_t), .Type = DTYPE_AudioInterface},
            .Subtype                  = DSUBTYPE_General,

            .TerminalLink             = 0x02,

            .FrameDelay               = 1,
            .AudioFormat              = 0x0001
        },

    .Audio_AudioFormat =
        {
            .Header                   = {.Size = sizeof(USB_Audio_Format_t), .Type = DTYPE_AudioInterface},
            .Subtype                  = DSUBTYPE_Format,

            .FormatType               = 0x01,
            .Channels                 = 0x01,
            
            .SubFrameSize             = 0x02,
            .BitResolution            = 16,
            .SampleFrequencyType      = AUDIO_TOTAL_SAMPLE_RATES,
        
            .SampleFrequencies        = {AUDIO_SAMPLE_FREQ(AUDIO_SAMPLE_FREQUENCY)}
        },
    
    .Audio_StreamEndpoint =
        {
            .Endpoint =
                {
                    .Header              = {.Size = sizeof(USB_Audio_StreamEndpoint_Std_t), .Type = DTYPE_Endpoint},

                    .EndpointAddress     = (ENDPOINT_DESCRIPTOR_DIR_IN | AUDIO_STREAM_EPNUM),
                    .Attributes          = (EP_TYPE_ISOCHRONOUS | ENDPOINT_ATTR_SYNC | ENDPOINT_USAGE_DATA),
                    .EndpointSize        = AUDIO_STREAM_EPSIZE,
                    .PollingIntervalMS   = 1
                },
            
            .Refresh                  = 0,
            .SyncEndpointNumber       = 0
        },
        
    .Audio_StreamEndpoint_SPC =
        {
            .Header                   = {.Size = sizeof(USB_Audio_StreamEndpoint_Spc_t), .Type = DTYPE_AudioEndpoint},
            .Subtype                  = DSUBTYPE_General,
            
            .Attributes               = 0x00,
            
            .LockDelayUnits           = 0x00,
            .LockDelay                = 0x0000
        }
};

// Сканирование шины PCI
// определяем значения смещений для пространства шины PCI
#define VENDOR_ID          0x00
#define DEVICE_ID          0x02
#define C_OD_E               0x04
#define STATUS             0x06
#define REVISION_ID        0x08
#define INTERFACE          0x09
#define SUBCLASS           0x0A
#define CLASSCODE          0x0B
#define CACHE_LINE_SIZE    0x0C
#define LATENCY_TIMER      0x0D
#define HEADER_TYPE        0x0E
#define BIST               0x0F
#define BASE_ADDRESS_0     0x10
#define BASE_ADDRESS_1     0x14
#define BASE_ADDRESS_2     0x18
#define BASE_ADDRESS_3     0x1C
#define BASE_ADDRESS_4     0x20
#define BASE_ADDRESS_5     0x24
#define CARDBUS_POINTER    0x28
#define SUBVEN_ID          0x2C
#define SUBSYSTEM_ID        0x2E
#define ROM_BASE_ADDRESS    0x30
#define INTERRUPT_LINE      0x3C
#define INTERRUPT_PIN       0x3D
#define MIN_GNT             0x3E
#define MAX_LAT             0x3F
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
int GetDeviceSlot(int iDevice, int iFunction)
{
   return ((((iDevice) & 0x1f) << 3) | ((iFunction) & 0x07));
}
//---------------------------------------------------------------------------
DWORD GetDevice(int iBusPCI, int iSlot, int iAddress)
{
   return (0x80000000L | ((iBusPCI & 0xff) << 16) | (iSlot << 8) | (iAddress & ~3));
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
// единственный аргумент функции определяет номер шины ( от 0 до 255 )
void ScanPCI(int iBusPCI)
{

   DWORD dwResult = 0;
   BYTE buffer[256];
   // создаем двойной цикл для перебора всех устройств
   for(int iDevice = 0; iDevice < 32; iDevice++)
   {
      for(int iFunction = 0; iFunction < 8; iFunction++)
      {
        memset(&buffer, 0, 256);
        // вычисляем номер очередного слота
        int iSlot = GetDeviceSlot(iDevice, iFunction);
        // проверяем поле Vendor ID для определения наличия устройства
        DWORD dwVendorID = 0;
        // получаем конфигурацию устройства
        dwResult = GetDevice(iBusPCI, iSlot, VENDOR_ID);
        // пишем в адресный порт параметры устройства
        SetPortVal(0xCF8, dwResult, 4);
        dwResult = 0;
        // читаем из порта данных идентификатор производителя
        GetPortVal(0xCFC, &dwResult, 4);
        // если полученное  значение равно 0 или 0xFFFFFFFF,  
        // выходим из вложенного цикла и продолжаем поиск
        if(dwVendorID == 0x00000000 || dwVendorID == 0xFFFFFFFF)
            break;
        DATA = 1;
        // если устройство присутствует, читаем его параметры
        // из конфигурационного пространства шины PCI
        for(int j = 1; j < 256; j++)
        {
          // получаем конфигурацию устройства
          dwResult = GetDevice(iBusPCI, iSlot, j);
          // пишем в адресный порт параметры устройства
          SetPortVal(0xCF8, dwResult, 4);
          // получаем из порта очередной байт
          GetPortVal(0xCFC + ( j&0x03 ), &dwResult, 1);
          // сохраняем полученный байт в буфер
          buffer[j] = dwResult;
          // здесь мы можем извлечь нужные данные из буфера и сохранить
          // их для последующего использования
          // например, получим номер прерывания для устройства
          // переменная uINT определена где-то ранее
          //uINT = buffer[INTERRUPT_LINE];
          // поле Header Type
          //uHeader = buffer[HEADER_TYPE];
          // поле Revision ID
          //uRevID = buffer[REVISION_ID];
          // поле Device ID
          dwDeviceID = ( (WORD) ( ( (BYTE) (buffer[DEVICE_ID]))  | ( ( (WORD) ( (BYTE) (buffer[DEVICE_ID] + 1) ) ) << 8) ) );
          // поле Cod_e
          dwC_od_e = ( (WORD) ( ( (BYTE) (buffer[C_OD_E]) )  | ( ( (WORD) ( (BYTE) (buffer[C_OD_E] + 1) ) ) << 8) ) );
          // поле Subsystem Vendor ID
          dwSubVendorID = ( (WORD) ( ( (BYTE) (buffer[SUBVEN_ID]) )  | ( ( (WORD) ( (BYTE) (buffer[SUBVEN_ID] + 1) ) ) << 8) ) );
          // базовый адрес 0
          WORD low = 0, high = 0;
          // получаем младшее слово адреса
          low = ( (WORD) ( ( (BYTE) (buffer[BASE_ADDRESS_0]) ) | ( ( (WORD) ( (BYTE) (buffer[BASE_ADDRESS_0] + 1) ) ) << 8) ) );
          // получаем старшее слово адреса
          high = ( (WORD) ( ( (BYTE) (buffer[BASE_ADDRESS_0] + 2) ) | ( ( (WORD) ( (BYTE) (buffer[BASE_ADDRESS_0] + 3) ) ) << 8) ) );
          // вычисляем полный адрес
          dwBaseAddress_0 = ( (LONG) ( ( (WORD) (low) ) |  ( ( (DWORD) ( (WORD) (high) ) ) << 16) ) );
        }
      }
   }
}