Atmega 2560

[omercury]

почему Мега может "жрать" в 2 раза больше?

Попробуй отключить всю периферию, наверняка ток уложится в заявленные рамки...

[papa_n]

Схему плз.
Наверняка к процессору что-то подключено. Вот это что-то и тянет дополнительный ток.

Спасибо уже разобрался, все отрезал потребляет 5 mA)

Я составил прожку, я конечно же не мастер, но вроди ничего, работает!
Кто бы указал на ошибки? вот текст:[HTML]/************************************************** ***
Chip type : ATmega2560
Program type : Application
Clock frequency : 3,686000 MHz
Memory model : Small
External RAM size : 0
Data Stack size : 2048
************************************************** ***/
#include ‹mega2560.h›
#include ‹delay.h›

#define RXB8 1
#define TXB8 0
#define UPE 2
#define OVR 3
#define FE 4
#define UDRE 5
#define RXC 7

#define FRAMING_ERROR (1‹‹FE)
#define PARITY_ERROR (1‹‹UPE)
#define DATA_OVERRUN (1‹‹OVR)
#define DATA_REGISTER_EMPTY (1‹‹UDRE)
#define RX_COMPLETE (1‹‹RXC)
/////////////////////////////////////////
#define RXD 0 //PJ0 63
#define TXD 1 //PJ1 64
#define RTS 2 //PJ2 65
#define DTR 3 //PJ3 66
#define CTS 4 //PJ4 67
#define DSR 5 //PJ5 68
#define DCD 6 //PJ6 69
#define RI 7 //PJ7 79
//////////////////////////////////////////////////////////
// Глобальные переменные Telit
char RX=0;
char a;
//flash char *at='at+cnmi=2,2,0,0;+crc=1;+cbst=71,0,1;+creg?;+c mgl="REC UNREAD";+cmgd=1,3';
volatile flash char basa_1[]="+380931477427";
//volatile flash char basa_2[];
//volatile flash char basa_3[];
flash char sms[]="at+cmgs=" ;
//flash char sms1[]="gZoucY7pgXS‹dbHmK0000200JB@2000000000000teSNX7i› hnBRMeA308TNX7C›hnBRMeA30DTNX73›hnhRMeQ30PTNX73=hn RRMeg40bTNX73=hnhRMeQ30XUNX7i?hn RRMeg200\r";
flash char sms1[]="39601-NORMA,http://maps.google.com.ua/maps?q=";
flash char sms2[]="&hl=ru\r";
// ---- НЕ ЗАБЫТЬ!!! в конце смс
//flash char sms1[]="Privet ot Atmel\r";
flash char at0[]="+++\r";
flash char at1[]="AT\r";
flash char at2[]="ath\r";
flash char at3[]="AT+IPR=115200\r";
flash char at4[]="ate1\r";
flash char at5[]="AT&D1\r";
flash char at6[]="at+crc=1\r";
//flash char at7[]="at+crc=1\r";
flash char at8[]="at+clip=1\r";
flash char at9[]="at+creg?\r";
flash char at10[]="AT+CMGF=1\r";
flash char at11[]="ATX4\r";
flash char at12[]="at&s2\r";
flash char at13[]="at+cnmi=2,2,0,0\r";
flash char at14[]="at&k1\r";
flash char at15[]="at+cfun=1\r";
//flash char at15[]="AT+IFC=?\r\n";
flash char at16[]= "at+cnmi=2,2,0,0;+crc=1;+cbst=71,0,1;+creg?;+cmgl= ";
flash char at17[]="REC UNREAD";
flash char at18[]=";+cmgd=1,3\r";
//////////////////////////////////////////////////////////////////
//Глобальные переменные GPS-NEO
volatile char RX_GPS[56];
char index_GPS=0;
char RXGP;

//////////////////////////////////////////////////////////////////
//-----------------Функции Telit----------------------------------
//////////////////////////////////////////////////////////////////
// Отправить символ в UART3 - Telit
#pragma used+
void putchar3(char c)
{
while ((UCSR3A & DATA_REGISTER_EMPTY)==0);
UDR3=c;
}
#pragma used-
//////////////////////////////////////////////////////////////////
// Взять принятый символ с UART3 - Telit
#pragma used+
char getchar3(void)
{
char status,data;
while (1)
{
while (((status=UCSR3A) & RX_COMPLETE)==0);
data=UDR3;
if ((status & (FRAMING_ERROR | PARITY_ERROR | DATA_OVERRUN))==0)
return data;
};
}
#pragma used-
/////////////////////////////////////////////////////////////////
//Отправка строки по UART3 - Telit
#pragma used+
void send(char flash *mas)
{
char data;
while (*mas)
{
data = *mas++;
putchar3(data);
}

}
#pragma used-
/////////////////////////////////////////////////////////////////
//Reset Telit
void reset_TELIT(void)
{
PORTF|=(1‹‹1); //PF1-- 1 --
delay_ms(2000);
PORTF&=~(1‹‹1); //PF1-- 0 -- Telit "RESET"
delay_ms(2000); //пауза
}
/////////////////////////////////////////////////////
//Включение и резет Telit
void start_TELIT(void)
{
delay_ms(1000);
PORTF|=(1‹‹0); //PF0-- 1 --
delay_ms(1000);
PORTF&=~(1‹‹0); //PF0-- 0 -- Telit "ON"
reset_TELIT();
}
////////////////////////////////////////////////////////////////////////
// AT comand initialization
void send_at_init(void)
{
int t=1000;
char a;

PORTJ&= ~(1‹‹DTR); // DTR --"0"
send(at0); // ++
//////////////////////////////////////////////////////////////////////////
L00: delay_ms(t);
send(at1); // AT
for(a=0; a‹10; a++) // проверить 10 принятых символов
{
RX=getchar3(); // взять принятый символ
while(RX==0x4B) // ждать "К"
{
RX=getchar3();
while(RX==0x0D) // ждать переход строки
{
goto L1; // переход к отправке следующей команды
}
}
}
goto L00;
///////////////////////////////////////////////////////////////////////////
L1: delay_ms(t);
send(at2); // ath
for(a=0; a‹11; a++) // проверить 11 принятых символов
{
RX=getchar3(); // взять принятый символ
while(RX==0x4B) // ждать "К"
{
RX=getchar3();
while(RX==0x0D) // ждать переход строки
{
goto L2; // переход к отправке следующей команды
}
}
}
goto L1;
/////////////////////////////////////////////////////////////////////////
L2: delay_ms(t);
send(at3); // AT+IPR=115200
for(a=0; a‹21; a++) // проверить 21 принятых символов
{
RX=getchar3(); // взять принятый символ
while(RX==0x4B) // ждать "К"
{
RX=getchar3();
while(RX==0x0D) // ждать переход строки
{
goto L3; // переход к отправке следующей команды
}
}
}
goto L2;
////////////////////////////////////////////////////////////////////////
L3: delay_ms(t);
send(at4); // ate1
for(a=0; a‹12; a++) // проверить 12 принятых символов
{
RX=getchar3(); // взять принятый символ
while(RX==0x4B) // ждать "К"
{
RX=getchar3();
while(RX==0x0D) // ждать переход строки
{
goto L4; // переход к отправке следующей команды
}
}
}
goto L3;
///////////////////////////////////////////////////////////////////////
L4: delay_ms(t);
send(at5); // AT&D1
for(a=0; a‹13; a++) // проверить 13 принятых символов
{
RX=getchar3(); // взять принятый символ
while(RX==0x4B) // ждать "К"
{
RX=getchar3();
while(RX==0x0D) // ждать переход строки
{
goto L5; // переход к отправке следующей команды
}
}
}
goto L4;
//////////////////////////////////////////////////////////////////////
L5: delay_ms(t);
send(at6); //at+crc=1
for(a=0; a‹16; a++) // проверить 16 принятых символов
{
RX=getchar3(); // взять принятый символ
while(RX==0x4B) // ждать "К"
{
RX=getchar3();
while(RX==0x0D) // ждать переход строки
{
goto L6; // переход к отправке следующей команды
}
}
}
goto L5;
////////////////////////////////////////////////////////////////////
//delay_ms(t);
//send(at7);
///////////////////////////////////////////////////////////////////
L6: delay_ms(t);
send(at; //at+clip=1
for(a=0; a‹17; a++) // проверить 17 принятых символов
{
RX=getchar3(); // взять принятый символ
while(RX==0x4B) // ждать "К"
{
RX=getchar3();
while(RX==0x0D) // ждать переход строки
{
goto L7; // переход к отправке следующей команды
}
}
}
goto L6;
//////////////////////////////////////////////////////////////////
L7: delay_ms(t);
send(at9); //at+creg?
for(a=0; a‹29; a++) // проверить 29 принятых символов
{
RX=getchar3(); // взять принятый символ
while(RX==0x4B) // ждать "К" --OK
{
RX=getchar3();
while(RX==0x0D) // ждать переход строки
{
goto L8; // переход к отправке следующей команды
}
}
}
goto L7;
///////////////////////////////////////////////////////////////////
L8: delay_ms(t);
send(at10); // AT+CMGF=1
for(a=0; a‹17; a++) // проверить 17 принятых символов
{
RX=getchar3(); // взять принятый символ
while(RX==0x4B) // ждать "К"
{
RX=getchar3();
while(RX==0x0D) // ждать переход строки
{
goto L9; // переход к отправке следующей команды
}
}
}
goto L8;
/////////////////////////////////////////////////////////////////
L9: delay_ms(t);
send(at11); // ATX4
for(a=0; a‹12; a++) // проверить 12 принятых символов
{
RX=getchar3(); // взять принятый символ
while(RX==0x4B) // ждать "К"
{
RX=getchar3();
while(RX==0x0D) // ждать переход строки
{
goto L10; // переход к отправке следующей команды
}
}
}
goto L9;
//////////////////////////////////////////////////////////////////
L10: delay_ms(t);
send(at12); // at&s2
for(a=0; a‹13; a++) // проверить 13 принятых символов
{
RX=getchar3(); // взять принятый символ
while(RX==0x4B) // ждать "К"
{
RX=getchar3();
while(RX==0x0D) // ждать переход строки
{
goto L11; // переход к отправке следующей команды
}
}
}
goto L10;
/////////////////////////////////////////////////////////////////
L11: delay_ms(t);
send(at13); // at+cnmi=2,2,0,0
for(a=0; a‹23; a++) // проверить 10 принятых символов
{
RX=getchar3(); // взять принятый символ
while(RX==0x4B) // ждать "К"
{
RX=getchar3();
while(RX==0x0D) // ждать переход строки
{
goto L12; // переход к отправке следующей команды
}
}
}
goto L11;
//////////////////////////////////////////////////////////////
L12: delay_ms(t);
send(at14); // at&k1
for(a=0; a‹13; a++) // проверить 13 принятых символов
{
RX=getchar3(); // взять принятый символ
while(RX==0x4B) // ждать "К"
{
RX=getchar3();
while(RX==0x0D) // ждать переход строки
{
goto L13; // переход к отправке следующей команды
}
}
}
goto L12;
//////////////////////////////////////////////////////////////
L13: delay_ms(t);
send(at15); // at+cfun=1
for(a=0; a‹17; a++) // проверить 10 принятых символов
{
RX=getchar3(); // взять принятый символ
while(RX==0x4B) // ждать "К"
{
RX=getchar3();
while(RX==0x0D) // ждать переход строки
{
goto L14; // переход к отправке следующей команды
}
}
}
goto L13;
//////////////////////////////////////////////////////////////
L14: delay_ms(t);
send(at9); // at+creg?
for(a=0; a‹29; a++) // проверить 29 принятых символов
{
RX=getchar3(); // взять принятый символ
while(RX==0x4B) // ждать "К" --OK
{
RX=getchar3();
while(RX==0x0D) // ждать переход строки
{
goto L15; // переход к отправке следующей команды
}
}
}
goto L14;
//////////////////////////////////////////////////////////
L15: delay_ms(t);
PORTJ|= (1‹‹DTR); // DTR --"1"
}
//////////////////////////////////////////////////////////////////
//Запрос Telit
void request(void)
{
PORTJ&= ~(1‹‹DTR); // DTR --"0"
send(at16); //
putchar3('"'); //
send(at17); //"at+cnmi=2,2,0,0;+crc=1;+cbst=71,0,1;+creg?;+cmgl= "REC UNREAD";+cmgd=1,3"
putchar3('"'); //
send(at1; //
PORTJ|= (1‹‹DTR); // DTR --"1"
}
/////////////////////////////////////////////////////////////////
//Ждать ответ CREG
void wait_CREG(void)
{
char a;
for(a=0; a‹32; a++) // проверить 32 принятых символов
{
RX=getchar3(); // взять принятый символ
while(RX==0x2B) // если "+"
{
RX=getchar3(); // проверить следующий
while(RX==0x43) // если "C"
{
RX=getchar3(); // следующий
while(RX==0x52) // если "R"
{
RX=getchar3(); // следующий
while(RX==0x45) // если "E"
{
RX=getchar3(); // следующий
while(RX==0x47) // если "G"
{
goto L0;
}
}
}
}
}
}
reset_TELIT();
send_at_init();
request();
L0: delay_ms(1);
}
/////////////////////////////////////////////////////////////////
void send_SMS(flash char *mas)
{
PORTJ&= ~(1‹‹DTR);// DTR --"0"
send(sms); //
putchar3('"'); //
send(mas); //
putchar3('"'); //
putchar3(','); // Команда отправки SMS на номер "mas"--basa_1, 2, 3
putchar3('1'); //
putchar3('4'); //
putchar3('5'); //
putchar3('\r'); //
PORTJ|= (1‹‹DTR); // 2 я ножка установлена в 1 DTR
}
/////////////////////////////////////////////////////////////////
void send_SMS1(void)
{
send(sms1); // отправить "Начало" ссылкы
putchar3('0'); //050+27.52897+030+26.18444 вставка в ссылку
putchar3(RX_GPS[2]); //L,5027.52368,N,03026.18713,E,072308.00,A
putchar3(RX_GPS[3]);
putchar3('+');
putchar3(RX_GPS[4]);
putchar3(RX_GPS[5]);
putchar3(RX_GPS[6]);
putchar3(RX_GPS[7]);
putchar3(RX_GPS[8]);
putchar3(RX_GPS[9]);
putchar3(RX_GPS[10]);
putchar3(RX_GPS[11]);
putchar3('+');
putchar3(RX_GPS[15]);
putchar3(RX_GPS[16]);
putchar3(RX_GPS[17]);
putchar3('+');
putchar3(RX_GPS[18]);
putchar3(RX_GPS[19]);
putchar3(RX_GPS[20]);
putchar3(RX_GPS[21]);
putchar3(RX_GPS[22]);
putchar3(RX_GPS[23]);
putchar3(RX_GPS[24]);
putchar3(RX_GPS[25]);
send(sms2);
}
/////////////////////////////////////////////////////////////////
void init_UART3_Telit(void)
{
// USART3 initialization
// Communication Parameters: 8 Data, 1 Stop, No Parity
// USART3 Receiver: On
// USART3 Transmitter: On
// USART3 Mode: Asynchronous
// USART3 Baud Rate: 115200
UCSR3A=0x00;
UCSR3B=0x18;
UCSR3C=0x06;
UBRR3H=0x00;
UBRR3L=0x01;
}



/////////////////////////////////////////////////////////////////
//----------------------Функции GPS-NEO--------------------------
/////////////////////////////////////////////////////////////////
// Взять принятый символ с UART2-GPS-NEO
#pragma used+
char getchar2(void)
{
char status,data;
while (1)
{
while (((status=UCSR2A) & RX_COMPLETE)==0);
data=UDR2;
if ((status & (FRAMING_ERROR | PARITY_ERROR | DATA_OVERRUN))==0)
return data;
};
}
#pragma used-
/////////////////////////////////////////////////////////////////
// Отправить символ по UART2-GPS-NEO
#pragma used+
void putchar2(char c)
{
while ((UCSR2A & DATA_REGISTER_EMPTY)==0);
UDR2=c;
}
#pragma used-
/////////////////////////////////////////////////////////////////
/*Функция получения координат и выдачи строчки пакета GLL
в формате "L,5027.52368,N,03026.18713,E,072308.00,A"
символьный масив от 0 до 40 */
#pragma used+
char GPS(char *RX_GPS)
{
while (1)
{
do
{
RXGP=getchar2();
}
while(RXGP!='L');

for(index_GPS=0; index_GPS‹42; index_GPS++)
{
RX_GPS[index_GPS]=getchar2();
}
while(RX_GPS[39]=='A')
{
while(RX_GPS[41]=='A')
{
return *RX_GPS;
}
//return *RX_GPS;
}
//return *RX_GPS;
}

}
#pragma used-
/////////////////////////////////////////////////////////////////
#pragma used+
void send_GPS(char *mas)
{
char data;
while (*mas)
{
data = *mas++;
putchar3(data);
}

}
#pragma used-
/////////////////////////////////////////////////////////////////
// USART2-GPS-NEO initialization
void init_UART2_GPS(void)
{
// Communication Parameters: 8 Data, 1 Stop, No Parity
// USART2 Receiver: On
// USART2 Transmitter: On
// USART2 Mode: Asynchronous
// USART2 Baud Rate: 9600
UCSR2A=0x00;
UCSR2B=0x18;
UCSR2C=0x06;
UBRR2H=0x00;
UBRR2L=0x17;
}
/////////////////////////////////////////////////////////////////
//====================Функции МК===============================
////////////////////////////////////////////////////////////////
void port_init(void)
{
// Input/Output Ports initialization
PORTA=0x00;
DDRA=0x00;
PORTB=0x00;
DDRB=0x00;
PORTC=0x00;
DDRC=0x00;
PORTD=0x00;
DDRD=0x00;
PORTE=0x00; // светодиоды не светятся
DDRE=0x0C; // выходы светодиодов
PORTF=0x00; //"0" ON/OFF Telit, "0" reset Telit
DDRF=0x03; // PF0, PF1 выходы управления Telit
PORTG=0x00;
DDRG=0x00;
PORTH=0x00;
DDRH=0x00;
PORTJ=0x0C; // 2,3 -- "1"
DDRJ=0x0C; //2,3 выходы RTS DTR
PORTK=0x00;
DDRK=0x00;
PORTL=0x00;
DDRL=0x00;
}
////////////////////////////////////////////////////////////////
..init timer
////////////////////////////////////////////////////////////////

void main(void)
{
// Локальные переменные
/////////////////////////////////////////////////////////////////
// Crystal Oscillator division factor: 1
#pragma optsize-
CLKPR=0x80;
CLKPR=0x00;
#ifdef _OPTIMIZE_SIZE_
#pragma optsize+
#endif
////////////////////////////////////////////////////////////////
port_init();
////////////////////////////////////////////////////////////////
init_mk();
////////////////////////////////////////////////////////////////
init_UART3_Telit();
////////////////////////////////////////////////////////////////
init_UART2_GPS();
////////////////////////////////////////////////////////////////
// Analog Comparator initialization
// Analog Comparator: Off
// Analog Comparator Input Capture by Timer/Counter 1: Off
ACSR=0x80;
ADCSRB=0x00;
///////////////////////////////////////////////////////////////////

start_TELIT(); // стартонуть Telit

while (PINJ & (1‹‹DSR)) { } // проверка DSR, ждать 0
while (PINJ & (1‹‹CTS)) { } // проверка CTS ждать 0
send_at_init(); // отправить набор АТ команд инициализации
//delay_ms(4000); // пауза

request(); //запрос
//"at+cnmi=2,2,0,0;+crc=1;+cbst=71,0,1;+creg?;+cmgl= "REC UNREAD";+cmgd=1,3"

wait_CREG(); // ждать ответа "+CREG:0.1"
delay_ms(3000);



GPS(RX_GPS); // получить координаты
PORTJ&= ~(1‹‹DTR); // 2 я ножка установлена в 0 DTR
send_SMS(basa_1); // отправка СМС вводная команда
PORTJ|= (1‹‹DTR); // DTR --"1"
delay_ms(3000);
send_SMS1(); // отправка СМС с координатами

PORTE=(1‹‹2)|(1‹‹3); // зажечь светодиоды



while(1)
{
L20:
RX=getchar3(); // проверить следующий
while(RX==0x2B) //'+'
{
RX=getchar3(); // проверить следующий
while(RX==0x33) // '3'
{
RX=getchar3(); // проверить следующий
while(RX==0x3 // '8'
{
RX=getchar3(); // проверить следующий
while(RX==0x30) //'0'
{
RX=getchar3();
while(RX==basa_1[4]) //номер + 3 8 0 9 3 1 4 7 7 4 2 7
{ // 0 1 2 3 4 5 6 7 8 9 .....
RX=getchar3();
while(RX==basa_1[5])
{
RX=getchar3();
while(RX==basa_1[6])
{
send(at2);
for(a=0; a‹11; a++) // проверить 11 принятых символов
{
RX=getchar3(); // взять принятый символ
while(RX==0x4B) // ждать "К"
{
RX=getchar3();
while(RX==0x0D) // ждать переход строки
{
goto L21; // переход далее
}
}
}
L21:
GPS(RX_GPS); // получить координаты
delay_ms(3000);
send_SMS(basa_1); // отправка СМС вводная команда
delay_ms(3000);
send_SMS1();
RX=0;
goto L20;
}
}
}
}
}
}
}
}




}
[/HTML]
Сейчас я это все разбил на модули GPS и GSM

[ForcePoint]

Кто бы указал на ошибки?

В функции port_init порты ставятся (в основном) в Z-состояние. Вот одна из причин повышенного энергопотребления. Плюс - отличный инструмент ловли помех.
Как минимум - выводы не задействованные в схеме надо поставить с подтяжками (pull-up, т.е. PORTxy = 1, DDRxy = 0).