Досега не съм програмирала на С,но се хванах с един проект,по които трябва6е други не6та да правя но ми дадоха да програмирам и сега ми е доста трудно.Трябва да програмирам микропроцесора Атмега16 да приема данни от GPS устройство,като вземам само геогр.дължина,ширина и височина(longitude,latitude,altitude) от всички данни които GPS-а предава.След това трябва да съхраня тези данни в нов Frame и да ги изпратя към друго устройство или компютър.Проблемът е че въобще не ми е ясно как да съхраня данните в нов Frame.Мога ли да си избера произволен регистър в които да съхраня данните или трябва да търся определен.
Използвам Win AVR и Pony Prog за компилатори.
Захранвам Борда с 6V.
Вземам данните от GPS-а чрез RS232,но ги подавам само на RX,TX и Ground към борда.
Прикачам схема на борда които използвам.

Дадоха ми две програми които да използвам.Това е програмата за приемника.
#include <AVR_special.h>

#define ATMEL_AVR 1
#define AVR_MEGA 1


#define INT_INTERRUPT1 SIG_INTERRUPT1
#define INT_TIMER0_OVERFLOW SIG_OVERFLOW0

#define EXT1_FLAG_REG GIFR
#define EXT1_ENABLE_REG GICR
#define EXT1_FLAG_MASK (1<<INTF1)
#define EXT1_ENABLE_MASK (1<<INT1)
#define EXT1_CONFIG_MASK1 (1<<ISC10)
#define EXT1_CONFIG_MASK2 (1<<ISC11)
#define EXT1_CONFIG_REG MCUCR


/** IO-Ports **/
#define DEBUG_DIR DDRC
#define DEBUG_PORT PORTC
#define DEBUG_MASK (1<<4)

#define DATA_DIR DDRC
#define DATA_PORT PORTC
#define DATA_ENTRY PINC
#define DATA_MASK (1<<2)

#define CLOCK_DIR DDRD
#define CLOCK_PORT PORTD
#define CLOCK_ENTRY PIND
#define CLOCK_MASK (1<<3)

#define DISPLAY_DIR DDRA
#define DISPLAY_PORT PORTA
#define DISPLAY_MASK 0xFF

#define PT_BIT_MAX 0x08

#define RISING_EDGE 0x01
#define FALLING_EDGE 0x10

#define extInt1_Occurred 0x10


volatile UBYTE OccurredFlags;


InterruptVektor(INT_INTERRUPT1)
{
// DEBUG_PORT ^= DEBUG_MASK;
OccurredFlags |= extInt1_Occurred;
}
/******************************************/

void delExtInt1_OccurredFlag()
{
disableInts();
OccurredFlags &= ~extInt1_Occurred;
enableInts();
}
/******************************************/
void initExtInt1(UBYTE type)
{
delExtInt1_OccurredFlag();

EXT1_CONFIG_REG |= EXT1_CONFIG_MASK2;
if (type == RISING_EDGE)
EXT1_CONFIG_REG |= EXT1_CONFIG_MASK1; /* enable _# Int */
if (type == FALLING_EDGE)
EXT1_CONFIG_REG &= ~EXT1_CONFIG_MASK1; /* enable #_ Int */

EXT1_FLAG_REG |= EXT1_FLAG_MASK;
EXT1_ENABLE_REG |= EXT1_ENABLE_MASK; /* enable #_ / _# Int */
}
/******************************************/
void exitExtInt1(void)
{
EXT1_ENABLE_REG &= ~EXT1_ENABLE_MASK; /* disable #_ / _# Int */

delExtInt1_OccurredFlag();
}
/******************************************/

void initDisplay(void)
{
DISPLAY_PORT &= ~DISPLAY_MASK;
DISPLAY_DIR |= DISPLAY_MASK;
}
/******************************************/
void display(UBYTE data)
{
DISPLAY_PORT = data;
}
/******************************************/

void initProtocol(void)
{
DEBUG_PORT &= ~DEBUG_MASK;
DATA_PORT |= DATA_MASK;
CLOCK_PORT |= CLOCK_MASK;

DEBUG_DIR |= DEBUG_MASK;
DATA_DIR &= ~DATA_MASK;
CLOCK_DIR &= ~CLOCK_MASK;
}
/******************************************/

UBYTE recvProtocolBit(void)
{
UBYTE data;

while (!(OccurredFlags & extInt1_Occurred));
delExtInt1_OccurredFlag();

if (DATA_ENTRY & DATA_MASK)
data = 0x80;
else
data = 0x00;

DEBUG_PORT ^= DEBUG_MASK;

return(data);
}
/******************************************/
UBYTE recvProtocolByte(void)
{
UBYTE data;
UBYTE index;
UBYTE check;

data = 0x00;

/** StartBit **/
check = recvProtocolBit();


for (index = 0x00; index < PT_BIT_MAX; index ++)
{
data >>= 0x01; // LSB first, MSB least
data |= recvProtocolBit();
}

/** (Pseudo)ParityBit **/
check = recvProtocolBit();
/** StoppBit **/
check = recvProtocolBit();

return(data);
}


/************************ MainProgram **********************************************/
int main( void )
{
UBYTE zeichen;

/** Init **/
initDisplay();
initProtocol();

initExtInt1(RISING_EDGE);
enableInts();

for (;;)
{
zeichen = recvProtocolByte();
DEBUG_PORT &= ~DEBUG_MASK;

display(zeichen);

}

return 0;
}
/******* End Main ************************************/

Това е програмата за предавателя:
#include <AVR_special.h>

#define ATMEL_AVR 1
#define AVR_STD 1
#define AVR_TINY 1


#define DEBUG_DIR DDRB
#define DEBUG_PORT PORTB
#define DEBUG_MASK 0x04

#define DATA_DIR DDRB
#define DATA_PORT PORTB
#define DATA_MASK 0x02

#define CLOCK_DIR DDRB
#define CLOCK_PORT PORTB
#define CLOCK_MASK 0x08


#define PT_BIT_MAX 0x08
#define PT_DELAY_MAX 0x06

void wait100us(UBYTE count)
{
UBYTE i,j;

for (i = 0x00; i < count; i++)
{
for (j = 0x00; j < 0xA0; j++)
{asm("nop");}
}
}
/******************************************/
void protocolDelay(void)
{
UBYTE index;

for (index = 0x00; index < PT_DELAY_MAX; index++)
{asm("nop");}
}
/******************************************/
void initProtocol(void)
{
DEBUG_PORT &= ~DEBUG_MASK;
DATA_PORT |= DATA_MASK;
CLOCK_PORT |= CLOCK_MASK;

DEBUG_DIR |= DEBUG_MASK;
DATA_DIR |= DATA_MASK;
CLOCK_DIR |= CLOCK_MASK;
}
/******************************************/
void sendProtocolBit(UBYTE data)
{
CLOCK_PORT &= ~CLOCK_MASK;

if (data == 0x00)
DATA_PORT &= ~DATA_MASK;
else
DATA_PORT |= DATA_MASK;

protocolDelay();
CLOCK_PORT |= CLOCK_MASK;
protocolDelay();
}
/******************************************/
void sendProtocolByte(UBYTE data)
{
UBYTE index;

DEBUG_PORT |= DEBUG_MASK;

/** StartBit **/
sendProtocolBit(0x00);

for (index = 0x00; index < PT_BIT_MAX; index++)
{
sendProtocolBit(data & 0x01);
data >>= 0x01; // LSB first, MSB least
}

/** (Pseudo)ParityBit **/
sendProtocolBit(0x00);
/** StoppBit **/
sendProtocolBit(0x01);

DEBUG_PORT &= ~DEBUG_MASK;
}
/******************************************/

/************************ MainProgram **********************************************/
int main( void )
{
UBYTE zeichen;

/** Init **/
initProtocol();
zeichen = 0x55;


for (;;)
{
sendProtocolByte(zeichen);
wait100us(0x02);

}

return 0;
}
/******* End Main ********************************************************************/


Моля ви ако можете да помогнете 6те съм много благодарна.
Мерси предварително

Pony Prog не е компилатор, но както и да е.
За да си съхраниш данните за longitude,latitude,altitude трябва да си избереш в какъв формат (дали ще е както ги приемаш като текст или ще float или някакъв друг).
Декларираш необходимите променливи или масиви.
Изваждаш си ги от съобщението GGA, VTG или в което се предаваха. Не помня вече.
След като имаш извлечени данните си ги подреждаш по необходимият начин във новият фрейм и ги изпращаш.

С Atmega не съм работил, но съм обработвал GPS информация с микроконтролер. Това ми е работата. Ако имаш по-конкретни въпроси, мога да ти "ударя едно рамо". Правил съм го на C за MSP430.

@bateAz само с "ударянето на едно рамо" няма да стане работата, като гледам . Ще трябва още нещо

Сега стана интересно - жена девелопърка.

Така като гледам, имаш всичко необходимо. Като начало, дефинираш структура, която съхранява данните, ето така:



После я пълниш с нещо:



Най-сложното е функцията за самото изпращане:



Този случай е максимално опростен - няма много важен компонент, синхронизацията. Ако си разбрала до тук, може да продължим.

Никога нямаше да се сетя да използвам структори,ти направо ми спря тока.Аз тука като се самообразовах по програмиране не6тото дето не ми стана много ясно са пойнтерите и структорите.
Освен това тези програми дето ги прика4их за приемнока и предавателя ги използвам за моита програма оба4е ми дава едни гре6ки при компилацията дето не мога да разбера 6то ми ги дава,казва 4е PORTC,DDRC,GICR,PORTA;DDRA,PINC undeclared,при условие 4е съм ги дефинирала в на4алото,което ми е о6те по интересно 6то стажа така.
Освен това за6то след tagCoordinate и UBYTE слага6 звезди4ка,компилатора и това не харесва ,както и рс.

П.С. Сори ако ви се струват глупави и елементарни мойте въпроси,ама наистина ми е много трудно,тука от един месец сама се у4а на С от разни статии на английскию(6тото не съм си в БГ) и не вси4ко ми е ясно.
Благодаря за помо6та и вниманието.

Да, работата със струкури е удобна. Точно така се прави, ама имам някои забележки:
1. Географските координати в 4-байтов Float не се чувстват комфортно, губи се точност. Ползва се или 32-битов Integer с прекодиране, или 8-байтов Float. Второто е най-лесно и най-грешно, защото не всеки компайлер го поддържа, трудно се смята, заема много място в паметта и е $$$ при комуникация.
2. Височината не заслужава чак 4-byte Float. Стигат й 2 байта Integer. Въпреки, че в NMEA се дава с точност до 0.1m, реалната точност е под няколко метра, така че 1 метър дискретизация му е достатъчен.
3. Ако вземеш да обработваш тези записи, неусетно ще откриеш, че ти трябва ОЩЕ информация. То винаги е добре да има още