ATNEL tech-forum 2013-12-23T12:08:14+01:00 https://forum.atnel.pl/feed.php?f=4&t=5203&mode 2013-12-23T12:08:14+01:00 2013-12-23T12:08:14+01:00 https://forum.atnel.pl/viewtopic.php?t=5203&p=62127#p62127 <![CDATA[Re: Kod w języku c. Proszę o sprawdzenie.]]> Statystyki: Napisane przez adi19887 — 23 gru 2013, o 12:08

]]> 2013-12-21T23:38:44+01:00 2013-12-21T23:38:44+01:00 https://forum.atnel.pl/viewtopic.php?t=5203&p=62014#p62014 <![CDATA[Re: Kod w języku c. Proszę o sprawdzenie.]]> Statystyki: Napisane przez Krauser — 21 gru 2013, o 23:38

]]> 2013-12-21T17:08:16+01:00 2013-12-21T17:08:16+01:00 https://forum.atnel.pl/viewtopic.php?t=5203&p=61980#p61980 <![CDATA[Re: Kod w języku c. Proszę o sprawdzenie.]]> Statystyki: Napisane przez adi19887 — 21 gru 2013, o 17:08

]]> 2013-12-19T21:46:13+01:00 2013-12-19T21:46:13+01:00 https://forum.atnel.pl/viewtopic.php?t=5203&p=61827#p61827 <![CDATA[Re: Kod w języku c. Proszę o sprawdzenie.]]> MirkoT napisał(a):

A co to ma do rzeczy? W AS też można w parametrach projektu wstawić taktowanie...
Pooglądaj poradniki Mirka


Np ten i od tego momentu:

http://www.youtube.com/watch?feature=pl ... 7vo#t=3015

Statystyki: Napisane przez mirekk36 — 19 gru 2013, o 21:46

]]> 2013-12-19T21:09:24+01:00 2013-12-19T21:09:24+01:00 https://forum.atnel.pl/viewtopic.php?t=5203&p=61825#p61825 <![CDATA[Re: Kod w języku c. Proszę o sprawdzenie.]]> adi19887 napisał(a):

Natomiast co do F_CPU to pracuje na atmel studio bo mnie eclipse nawalil ostatnio i nie chce ożyć,

A co to ma do rzeczy? W AS też można w parametrach projektu wstawić taktowanie...
Pooglądaj poradniki Mirka

Statystyki: Napisane przez MirkoT — 19 gru 2013, o 21:09

]]> 2013-12-18T18:03:56+01:00 2013-12-18T18:03:56+01:00 https://forum.atnel.pl/viewtopic.php?t=5203&p=61676#p61676 <![CDATA[Re: Kod w języku c. Proszę o sprawdzenie.]]> Statystyki: Napisane przez adi19887 — 18 gru 2013, o 18:03

]]> 2013-12-18T17:31:03+01:00 2013-12-18T17:31:03+01:00 https://forum.atnel.pl/viewtopic.php?t=5203&p=61668#p61668 <![CDATA[Re: Kod w języku c. Proszę o sprawdzenie.]]> FUJ wywal to coś :)
http://mirekk36.blogspot.com/2013/01/rs ... trick.html

Statystyki: Napisane przez D_C — 18 gru 2013, o 17:31

]]> 2013-12-18T17:22:23+01:00 2013-12-18T17:22:23+01:00 https://forum.atnel.pl/viewtopic.php?t=5203&p=61664#p61664 <![CDATA[Re: Kod w języku c. Proszę o sprawdzenie.]]> adi19887 napisał(a):

ponieważ teraz program reaguje (wysyła bez usart ciąg taki jak powinien tylko, że z samymi zerami np. 254 0 0 0 0 0 0 0 0 0 0)


to taki jak powinien czy nie taki ?

Statystyki: Napisane przez acid3 — 18 gru 2013, o 17:22

]]> 2013-12-18T17:18:09+01:00 2013-12-18T17:18:09+01:00 https://forum.atnel.pl/viewtopic.php?t=5203&p=61663#p61663 <![CDATA[Kod w języku c. Proszę o sprawdzenie.]]>
Chciałbym prosić osoby obeznane o sprawdzenie kodu który wklejam:
[syntax=c]//Definicje
#define F_CPU 16000000UL
#define BAUD 9600
#define MYUBRR (( F_CPU + BAUD * 8UL ) / (16UL * BAUD) -1)
#define RESET_DDS 0x2100
#define NORMAL_DDS 0x2002
#define DDS_SCS 0x02
#define DDS_PORT PORTB
#define DDS_DATA 0x08
#define DDS_SCLK 0x20
#define DDS_DDR DDRB
#define VREF 4.93
#define ADCIN PC0

//Pliki nagłówkowe
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>

//Zmienne
volatile int licznik = 0;
volatile uint16_t reszta;
volatile uint16_t czestotliwosc; //Zmierzona czestotliwosc
volatile uint8_t przepelnienie = 61; //Timer0 8 bit przy kwarcu 16MHz
volatile uint8_t sekunda_flaga;
volatile uint8_t flaga_konca_pomiaru_czestotliwosci =0;

//Tablice

//STRUKTURA DO POMIARU
volatile uint8_t flagaADC;
volatile uint8_t currentadc =0;
volatile uint16_t ppomiar[20];
uint8_t flaga_rozpoczecie_synch = 0; //informuje o rozpoczęciu komunikacji z PC

volatile struct pomiarADC
{
uint16_t probki[20];
uint16_t pomiary[20];
uint16_t wart_max[1];
uint16_t wart_min[1];
uint16_t amplituda[10];
}pomiar;

volatile struct dane_z_PC
{
uint8_t czestotliwosc[10]; //Tutaj laduja czestotliwosci podzielone przez 10 !!!
uint16_t czestotliwoscx10[10]; // Tutaj laduja czestotliwosci przemnozone przez 10!!!
uint8_t liczba_pomiarow; // jezeli 1 to 10 pomiarow, jezeli 0 to 1 pomiar.
}dane;

volatile struct dane_do_PC
{
uint8_t amplituda_do_PC[10]; //amplituda podzielona przez 10;
}dane_do_PC;

volatile struct pomiar_freq
{
uint16_t czestotliwoscDDS[10];
uint16_t blad_bezwzgledny;
uint16_t blad_wzgledny;
}freq;
//FUNKCJE
//SPI
void DDS_Write(uint16_t Write)
{
signed char i;

DDS_PORT &= ~DDS_SCS;
_delay_us(1);
for (i=15;i!=-1;i--)
{
if (Write &(1<<i)) DDS_PORT |= DDS_DATA;
else DDS_PORT &= ~DDS_DATA;
_delay_us(1);
DDS_PORT &= ~DDS_SCLK;
_delay_us(1);
DDS_PORT |= DDS_SCLK;
}
_delay_us(1);
DDS_PORT |= DDS_SCS;
}

void DDS_Init(void)
{
DDS_DDR |= DDS_DATA +DDS_SCLK+ DDS_SCS;
DDS_PORT |= DDS_DATA +DDS_SCLK+ DDS_SCS;
DDS_Write(0b0010000100000000);// Reset
DDS_Write(0b0010000000000000);// Normal
}

void SetDDSFrequancy(float Freq)//podawane podzielone przez 100
{
long i,lsb,msb;

//Freq = Freq / 0.186264515f; // for 50Mhz osc
Freq = ((Freq*100) / 0.093132258); // for 25Mhz


i = (long)Freq;
lsb = (i & 0x3fff) + 0x4000;
msb = ((i>>14) & 0x3fff) + 0x4000;
DDS_Write(lsb);
DDS_Write(msb);
}
//END_SPI
//USART
void USART_Init( unsigned int ubrr)
{
/* Set baud rate */
UBRRH = (unsigned char)(ubrr>>8);
UBRRL = (unsigned char)ubrr;
/* Enable receiver and transmitter */
UCSRB = (1<<RXEN)|(1<<TXEN);
/* Set frame format: 8data, 2stop bit */
UCSRC = (1<<URSEL)|(1<<USBS)|(3<<UCSZ0);
}

void usart_putc(unsigned char c)
{
// wait until UDR ready
while(!(UCSRA & (1 << UDRE)));
UDR = c; // send character
}
char odbierz(void)
{
/* Wait for data to be received */
while ( !(UCSRA & (1<<RXC)) )
;
/* Get and return received data from buffer */
return UDR;
}
//END_USART
//ADC
void inicjalizacja_przetwornik()
{
ADCSRA|=
/*|(1<< ADFR)*/
(1<< ADPS2) // CLK/128; 125kHz
|(1<< ADPS1)
|(1<< ADPS0)
|(1<< ADIE)
/*|(1<<ADIF)*/;


ADMUX |=(1<<REFS1)|(1<<REFS0)/*|(1<<MUX0)*/; // Referencja Vcc z zewnetrznym kondensatorem

/*PORTC&=~0x3E;*/

}
void obrobka()
{
pomiar.wart_max[0] = pomiar.pomiary[0];
pomiar.wart_min[0] = pomiar.pomiary[0];

uint8_t j;
for(j=0;j<=19;j++)
{

if(pomiar.pomiary[j]>pomiar.wart_max[0])
pomiar.wart_max[0]=pomiar.pomiary[j];
if(pomiar.pomiary[j]<pomiar.wart_min[0])
pomiar.wart_min[0]=pomiar.pomiary[j];

}
}

void przetworzenie()
{
for(int i =0; i<10;i++)
{
dane.czestotliwoscx10[i] = dane.czestotliwosc[i]*10; //Przemnazam przez 10 i zapisuje do nowej tablicy
}
}
//PRZERWANIE OD ADC
ISR(ADC_vect)
{

pomiar.probki[currentadc]=ADCW;



if(++currentadc==19)
{
currentadc=0;

ADCSRA&=~(1<<ADFR);
for(int i=0;i<=19;i++)
pomiar.pomiary[i]=pomiar.probki[i];

}


}
//END_PRZERWANIE OD ADC
//PRZERWANIA OD TIMERA1 i TIMERA0
ISR(TIMER0_OVF_vect) //odmierza 1s.
{
przepelnienie--;
if(przepelnienie == 0)
{
sekunda_flaga=1;
przepelnienie =61;

}
}

ISR(TIMER1_OVF_vect)
{
licznik++;
}
//END_PRZERWANIA OD T1 i T0
//END_ADC
//TIMER
void inicjalizacja_timery()
{
//PORTB &=~(1<<PB0); Dioda tutuaj była

//Wejście T1 podciągamy do +
DDRB &=~(1<<PB5);
PORTB |=(1<<PB5);
//Ustawianie Timera0
TCCR0 |= (1<<CS02)|(1<<CS00); // preskaler 1024
//TIMSK |= (1<<TOIE0)|(1<<TOIE1); //Przerwania od timera0
//Ustawienie Timera1
TCCR1B|=(1<<CS12)|(1<<CS11)|(1<<CS10);//External event
//TIMSK |= (1<<TOIE1);
}


void timer_obrobka()
{
if(sekunda_flaga==1)
{
sekunda_flaga = 0;
reszta=TCNT1;
TCNT1=0;
czestotliwosc=licznik*65536;
czestotliwosc=czestotliwosc+reszta;
flaga_konca_pomiaru_czestotliwosci =1;
}
}
//END_TIMER
//PORTY
void porty()
{

}
//END porty
//INICJALIZACJA Wszytsko
void inicjalizacja_komponentow(unsigned int ubrr)
{
DDS_Init();
inicjalizacja_przetwornik();
USART_Init(ubrr);
inicjalizacja_timery();
}
//END
//MAIN
int main()
{
inicjalizacja_komponentow(MYUBRR);
sei();
while(1)
{
//Najpierw Uart - czeka na odbió danych od PC, Jeżeli odbierze flagę 255 to zaczyna odbiór wartosci częstotliwosci[10], jak odbierze to robi prawdziwym warunek rozpoczęcia głównej pętli.
flaga_rozpoczecie_synch = odbierz();
if(flaga_rozpoczecie_synch == 255)
{

for(int i = 0; i<10;i++)
{
dane.czestotliwosc[i] = odbierz();
przetworzenie();
dane.liczba_pomiarow =1;
}

}else
if(flaga_rozpoczecie_synch == 254)
{
dane.czestotliwosc[0] = odbierz();
dane.czestotliwoscx10[0] = dane.czestotliwosc[0]*10;
dane.liczba_pomiarow = 0;
}

//End uart
//Własciwy kod
if((dane.liczba_pomiarow==1))
{

for(int i=0;i<10;i++) //Petla pomiarowa
{
SetDDSFrequancy(dane.czestotliwoscx10[i]/100);
_delay_ms(1000); //Deklay na ustabilizowanie się
//przełaczam Relay
DDRB |= (1<<PB2); //jako wyjscie
PORTB&= ~(1<<PB2);

//Koniec Relay
//Pomiar czestotliwości sygnału DDS_out

TIMSK |= (1<<TOIE1)|(1<<TOIE0);


do{
timer_obrobka();
}while(flaga_konca_pomiaru_czestotliwosci ==1);

TIMSK &=~(1<<TOIE1);//Wyłączam możliwość przrwań od timera0 i timera1
TIMSK &=~(1<<TOIE0);
freq.czestotliwoscDDS[i] = czestotliwosc; //Zapisuję próbkę z pomiary czestotliwosci
freq.blad_bezwzgledny = dane.czestotliwoscx10[i] - freq.czestotliwoscDDS[i];
freq.blad_wzgledny = (freq.blad_bezwzgledny/dane.czestotliwosc[i])*100;
if(freq.blad_wzgledny >10)
{
//błąd !!!
}
//Przełączam Relay
PORTB|= (1<<PB2); //stan wysoki na czas pomiaru.
//Koniec Relay
//Czekam na stabilizacje na wzmacniaczu
_delay_us(100);
//Koniec czekania
//pomiar napiecia ADC układu pomiarowego.

ADCSRA |= (1<<ADFR);
_delay_ms(2);
ADCSRA |=(1<ADEN);
_delay_ms(2); //Inicjalizuje się ok 2ms
ADCSRA |= (1<<ADSC); //włączam konwersję.
_delay_ms(30); //CZas na zebranie 20 probek ok 15ms
//Wylaczam ADC w przerwaniu !!!ADCSRA&=~(1<<ADFR);
ADCSRA &=~(1<ADEN);
obrobka();
pomiar.amplituda[i]=(pomiar.wart_min[0] + pomiar.wart_max[0])/2 ;//wyliczam amplitude sygnału, do welementow tablicy zapisane probki w postaci wartosci rejestru ADC
pomiar.amplituda[i] = pomiar.amplituda[i]/10; //Dziele przez 10 zeby sie zmiescilo w zmiennej
//Koniec pomiarów !!!
}
//USART wysyłanie.
usart_putc(0xFF); // Synchronizacja;
for(int i=0;i<10;i++)
{
usart_putc(pomiar.amplituda[i]); // wysyła 10 pomiarów.!!! Koniec do początku.
}

}else
if((dane.liczba_pomiarow == 0))
{
SetDDSFrequancy(dane.czestotliwoscx10[0]/100);
_delay_ms(1000); //Deklay na ustabilizowanie się
//przełaczam Relay
DDRB |= (1<<PB2); //jako wyjscie
PORTB&= ~(1<<PB2);

//Koniec Relay
//Pomiar czestotliwości sygnału DDS_out

TIMSK |= (1<<TOIE1)|(1<<TOIE0);

do{
timer_obrobka();
}while(flaga_konca_pomiaru_czestotliwosci ==1);

TIMSK &=~(1<<TOIE1);//Wyłączam możliwość przrwań od timera0 i timera1
TIMSK &=~(1<<TOIE0);
_delay_ms(10);
freq.czestotliwoscDDS[0] = czestotliwosc; //Zapisuję próbkę z pomiary czestotliwosci
freq.blad_bezwzgledny = dane.czestotliwoscx10[0] - freq.czestotliwoscDDS[0];
freq.blad_wzgledny = (freq.blad_bezwzgledny/dane.czestotliwosc[0])*100;
if(freq.blad_wzgledny >10)
{
//błąd !!!
}
//Przełączam Relay
//PORTB|= (1<<PB2); //stan wysoki na czas pomiaru.
//Koniec Relay
//Czekam na stabilizacje na wzmacniaczu
_delay_us(100);
//Koniec czekania
//pomiar napiecia ADC układu pomiarowego.

ADCSRA |= (1<<ADFR);
_delay_ms(2);
ADCSRA |=(1<ADEN);
_delay_ms(2); //Inicjalizuje się ok 2ms
ADCSRA |= (1<<ADSC); //włączam konwersję.
_delay_ms(30); //CZas na zebranie 20 probek ok 15ms
//Wylaczam ADC w przerwaniu !!!ADCSRA&=~(1<<ADFR);
ADCSRA &=~(1<ADEN);
obrobka();
pomiar.amplituda[0]=(pomiar.wart_min[0] + pomiar.wart_max[0])/2 ;//wyliczam amplitude sygnału, do welementow tablicy zapisane probki w postaci wartosci rejestru ADC
pomiar.amplituda[0] = pomiar.amplituda[0]/10; //Dziele przez 10 zeby sie zmiescilo w zmiennej
pomiar.amplituda[1] =0;
pomiar.amplituda[2] =0;
pomiar.amplituda[3] =0;
pomiar.amplituda[4] =0;
pomiar.amplituda[5] =0;
pomiar.amplituda[6] =0;
pomiar.amplituda[7] =0;
pomiar.amplituda[8] =0;
pomiar.amplituda[9] =0;
usart_putc(0xFE);
for(int i=0;i<10;i++)
{
usart_putc(pomiar.amplituda[i]); // wysyła 10 pomiarów.!!! Koniec do początku.
}

}

//END
}
}[/syntax]

Nieco przydługi jednak mam problem, myślę, z przerwaniami. Bardzo proszę o sprawdzenie mojego toku myślenia, ponieważ teraz program reaguje (wysyła bez usart ciąg taki jak powinien tylko, że z samymi zerami np. 254 0 0 0 0 0 0 0 0 0 0) jednak chciałbym, żeby coś zmierzył na ADC i potem trochę przerobił i wysyłał.

Statystyki: Napisane przez adi19887 — 18 gru 2013, o 17:18

]]>