ATNEL tech-forum

Re: [m8] Jak zgrać z sobą przerwania od uarta i zwykle z tim

2012-10-26T13:54:57+01:00

Więc jak zrobisz w oparciu o to co w książce - korzystając z tych bibliotek - to potem śmiało wklej w razie czego swój plik main.c gdybyś jeszcze miał kłopoty jakieś i szybko wspólnie pomożemy ich się pozbyć

Statystyki: Napisane przez mirekk36 — 26 paź 2012, o 13:54

Re: [m8] Jak zgrać z sobą przerwania od uarta i zwykle z tim

2012-10-26T11:55:39+01:00

Ok, wrócę do twojego rozwiązania z DS`em (biblioteka) i spróbuję darować sobie bufor cykliczny, dam go do odbierania danych ale to jak to będzie działało poprawnie

Statystyki: Napisane przez orideith — 26 paź 2012, o 11:55

Re: [m8] Jak zgrać z sobą przerwania od uarta i zwykle z tim

2012-10-26T11:27:33+01:00

orideith napisał(a):

Mirek, źle mnie zrozumiałeś, tam zakomentowane jest przerwanie, bo z nim nie działało,

Widziałem że jest zakomentowane ale to kolejny twój błąd - a to z tego powodu że nie do końca zrozumiałeś na jakiej zasadzie wysyła się dane przez UART .... no zobacz - potem w timerze masz:

Code:

UDR = UART_TxBuf[UART_TxTail];

to jest straszny ZONK

bufor cykliczny przygotowany jest SPECJALNIE, podkreślam SPECJALNIE do współpracy z przerwaniami - naprawdę MUSISZ jeszcze raz o nim przeczytać rozdział, a ty sobie niefrasobliwie - bo coś tam nie działało - na zasadzie "a może się uda" przeniosłeś kod z przerwania UART'a do przerwania Timera - w takim wykonaniu BĘDZIE SIĘ TO GRYZŁO niestety

orideith napisał(a):

bibliotekę sprawdzę (ds), tą wcześniej używałem dlatego dałem.

A ok, no rozumiem ... ale polecam ci jednak tą z książki, tylko nie myśl że chodzi mi tu o propagowanie mojej biblioteki bo jest najlepsza na świecie - tak nawiasem mówiąc to nie moja biblioteka i podaję w książce autora, ja ją tylko co nieco zmodyfikowałem.

orideith napisał(a):

Z jednej strony z tym wysyłaniem naraz masz racje, ale danych będzie więcej. I przyznam się szczerze, że nie wiem jak policzyć czy się zmieszczę,

Jeśli chodzi o wysyłanie z poziomu pętli głównej to nie musisz nic liczyć - WSZYSTKO zmieścisz

orideith napisał(a):

Dane będą miały format mniej więcej
temperatura (liczba czujników 1 do 20) wilgotność (1-5) (inne parametry sztuk 5-10) i to za jednym ciągiem wysyłane, w jakim czasie je powinienem wysyłać?, kiedy tak naprawdę zabraknie mi czasu przy wysyłaniu bez bufora, prędkość mam 9600 ale i 115200 działa ok bo mam 14745600 kwarc więc mogę więcej wyciągnąć.

Ty się nie martw na zapas bo ja myślę że przy 9600 się zmieścisz a przy 115200 to zapomnij nawet o tym żeby się w najmniejszym stopniu martwić o to czy zdążysz ? ... raczej musiałbyś się starać o to aby zapchać taką transmisję

orideith napisał(a):

Czy te wszystkie dane pakować do jednej zmiennej dać w pętli uart_putc czy inaczej się to rozwiązuje?, chciałbym to w jednej linii dać bo jedna paczka to jeden rekord w bazie danych
Pozdrawiam i dzięki za poprzednie odpowiedzi

ZDECYDOWANIE można w jednej paczce - w jednej linii. Zwracaj tylko uwagę na rozmiary tej wypychanej linii względem wielkości buforów cyklicznych (nadawczych)

reasumując - wszystko ci się uda - tylko najpierw do testów - próbuj zrobić porządek na mniejszym kodzie testowym z wysyłaniem mniejszej ilości ale POPRAWNIE a nie w taki sposób OK ?

Statystyki: Napisane przez mirekk36 — 26 paź 2012, o 11:27

Re: [m8] Jak zgrać z sobą przerwania od uarta i zwykle z tim

2012-10-26T11:13:24+01:00

Mirek, źle mnie zrozumiałeś, tam zakomentowane jest przerwanie, bo z nim nie działało, bibliotekę sprawdzę (ds), tą wcześniej używałem dlatego dałem.
Z jednej strony z tym wysyłaniem naraz masz racje, ale danych będzie więcej. I przyznam się szczerze, że nie wiem jak policzyć czy się zmieszczę,
Dane będą miały format mniej więcej
temperatura (liczba czujników 1 do 20) wilgotność (1-5) (inne parametry sztuk 5-10) i to za jednym ciągiem wysyłane, w jakim czasie je powinienem wysyłać?, kiedy tak naprawdę zabraknie mi czasu przy wysyłaniu bez bufora, prędkość mam 9600 ale i 115200 działa ok bo mam 14745600 kwarc więc mogę więcej wyciągnąć.
Czy te wszystkie dane pakować do jednej zmiennej dać w pętli uart_putc czy inaczej się to rozwiązuje?, chciałbym to w jednej linii dać bo jedna paczka to jeden rekord w bazie danych
Pozdrawiam i dzięki za poprzednie odpowiedzi

Statystyki: Napisane przez orideith — 26 paź 2012, o 11:13

Re: [m8] Jak zgrać z sobą przerwania od uarta i zwykle z tim

2012-10-26T10:28:29+01:00

To co pisze kolega wyżej to JEDNO .... (to co zrobiłeś w tym przerwaniu timera2 to po prostu totalne nieporozumienie

I jak można po takim kodzie pisać że timer2 gryzie się z UART'em ? One się nie gryzą - wcale - to ty je podpuściłeś na siebie i jeden blokuje drugiego ..... TAK nie można

masz w książce przykład jak wysyłać dane zarówno w wersji z buforem jak i bez. Ja dodam od siebie, że akurat samo wysyłanie przez UART jest tak mało krytyczne, że najspokojniej w świecie można je zrobić nawet bez buforów cyklicznych - ot tak wprost w poolingu i z pętli głównej po pomiarze

Za to już całkowitą moją konsternację budzi fakt, że masz w książce tzn na DVD świetne biblioteki do 1wire, i to już z crc, tymczasem ty używasz innych .... które .... hmmm teraz nie będę ich analizował ale po prostu mogą mieć jeszcze błędy - skoro z marszu nie było wszczepionego crc.

Skąd takie pomysły ?

Wystarczyłoby użyć dokładnie tego przykładu który jest w książce i dodać bibliotekę UART do niego i po każdym pomiarze w pętli głównej (dokonywanym przy pomocy timerów programowych) od razu wysyłać dane do terminala, NAWET w tej funkcji, która wyświetla wyniki ....

wtedy BEZ ŻADNYCH kombinacji miałbyś zrealizowane WSZYSTKO co zamierzałeś .... oczywiście wiadomo, że warto ten projekt z DVD pozmieniać nieco i dostosować do własnych potrzeb (mówię tu o main.c)

Statystyki: Napisane przez mirekk36 — 26 paź 2012, o 10:28

Re: [m8] Jak zgrać z sobą przerwania od uarta i zwykle z tim

2012-10-26T10:14:07+01:00

Jest i będzie opóźnienie .......... zobacz co żeś uczynił w przerwaniu ........ Wysyłasz tam dane stąd te opóźnienia.
Przenieś wysyłanie do pętli głównej ..........

Statystyki: Napisane przez Malutki_27 — 26 paź 2012, o 10:14

[m8] Jak zgrać z sobą przerwania od uarta i zwykle z timera

2012-10-26T09:57:49+01:00

Witam Was, zrobiłem sobie czysto testowo kod, który wyświetla temperaturę na LCD oraz wysyła ją do komputera.
Pomysły rozwojowe były trzy.
1. wszystko w pętli + delay i to działa, wiem że nie zalecane ale działa, czyli odczyt temperatury oraz wysyłanie danych za pomocą podstawowej funkcji na wysyłanie danych z dokumentacji
2. wywalenie delaya dodanie timera oraz timera programowego takiego jak stosowany do odczytu temperatury w książce
3. to co powyżej tylko dodanie przerwania na wysyłanie danych z uarta oraz dodanie bufora cyklicznego.
Problem polega na tym, że timer2 (chyba) atmegi8 kłóci się z przerwaniem od uarta. Nie wiem jak ale odczyt temperatury zamiera i jest pokazywana ta sama temperatura.
Program nie zawiesza się, ale jest jak by opóźnienie przy wysyłaniu danych w pętli głównej.
Kod teraz wygląda tak
[syntax=c]
#include
#include
#include
#include
#include "uart.h"
#include "HD44780.h"
#include "ds18b20.h"
#include "1WireLib.h"
#include "konwersja_temp.h"
int16_t temp_ds[] = { 0, 1 };
char *temp2;
unsigned char temp[4];
volatile uint16_t Timer1, Timer2;
volatile uint8_t s1_flag, sekundy;
// 14745600
void Timer2_Init(void);
void USART_Transmit(unsigned int data);
union int16_t_LSB_MSB {
struct {
uint8_t LSB;
uint8_t MSB;
};

int16_t XSB;
};
union int16_t_LSB_MSB Temperature;

int main(void) {
LCD_Initalize();
USART_Init(9600, 0);
Timer2_Init();
sei();
while (1) {

if (s1_flag) {
LCD_GoTo(0, 0);
if ((sekundy % 3) == 0) {

initConversion(1);
}
if ((sekundy % 3) == 1) {

//LCD_WriteText("1");
readTemp(temp, 1);
Temperature.LSB = temp[0];
Temperature.MSB = temp[1];
temp_ds[1] = Temperature.XSB;
temp2 = Display_Temperature(temp_ds[1]);
}
if ((sekundy % 3) == 2) {
while (*temp2) {
uart_putc(*temp2++);
}
uart_putc('\n');
uart_putc('\r');
}

s1_flag = 0;
LCD_GoTo(0, 0);

LCD_WriteText(temp2);

}

}

}

void Timer2_Init(void) {
TCCR2 |= (1 << WGM21); // tryb CTC
TCCR2 |= (1 << CS20) | (1 << CS21) | (1 << CS22); // Preskaler 1024
OCR2 = 144; // Przerwanie porównania co 10ms (100Hz)
TIMSK |= (1 << OCIE2); // Odblokowanie przerwania CompareMatch
}

/*
ISR(USART_UDRE_vect) {
if (UART_TxHead != UART_TxTail) {
UART_TxTail = (UART_TxTail + 1) & UART_TX_BUF_MASK;
UDR = UART_TxBuf[UART_TxTail];
} else {
UCSRB &= ~(UDRIE);
}

}
*/ISR(TIMER2_COMP_vect) {
static uint8_t cnt = 0;

if (++cnt > 99) { // 100ms * 99 = 999ms = 1s
s1_flag = 1;
sekundy++;
if (sekundy > 59)
sekundy = 0;
cnt = 0;

}

if (uart_przerwanie == 1) {
if (UART_TxHead != UART_TxTail) {
UART_TxTail = (UART_TxTail + 1) & UART_TX_BUF_MASK;
UDR = UART_TxBuf[UART_TxTail];
} else {
//UCSRB &= ~(UDRIE);
}
uart_przerwanie = 0;
}

uint16_t x;
x = Timer1; // 100Hz Timer1
if (x)
Timer1 = --x;
x = Timer2; // 100Hz Timer2
if (x)
Timer2 = --x;
}

[/syntax]

kod na uart tak
[syntax=c]
#include "uart.h"
#include
void uart_putc(char data) {
uint8_t tmp_head;
tmp_head = (UART_TxHead + 1) & UART_TX_BUF_MASK;
while (tmp_head == UART_TxTail) {}
UART_TxBuf[tmp_head] = data;
UART_TxHead = tmp_head;
//UCSRB |= (1 << UDRIE);
uart_przerwanie = 1;

}

void USART_Init(uint32_t baud, uint8_t speed) {
uint16_t _ubr;
if (speed == 1) {
UCSRA |= (1 << U2X);
_ubr = (F_CPU / 8 / baud - 1);
} else {
_ubr = (F_CPU / 16 / baud - 1);
}
UBRRH = (unsigned char) (_ubr >> 8);
UBRRL = (unsigned char) _ubr;
/* Enable receiver and transmitter */
UCSRB = (1 << RXEN) | (1 << TXEN);
/* Set frame format: 8data, 2stop bit */
UCSRC = (1 << URSEL) | (1 << USBS) | (3 << UCSZ0);
}

[/syntax]

Zastosowałem zmienną uart_przerwanie która daje znać by dane zostały wysłane jeżeli coś się w buforze pojawi, nie wiem czy tak jest poprawnie ale inaczej nie chce działać. Pytanie czy dobrze robię, może coś pominąłem.
kod na odczyt temperatury

[syntax=c]
//////////// BIBLIOTEKA OBS�UGI DS18B20///////////////
////////////////////////////////AUTOR:JAN G�RSKI//////
////////////////////////////////http://mathmed.blox.pl
#include
#include "DS18B20.h"
#include "1WireLib.h"
//////////////////////////////////////////////////////
void initConversion(unsigned char device) {
useDevice(device);
sendByte1Wire(CONVERT_T);
}

uint8_t CRC8_2(uint8_t *inData, uint8_t len)
{
uint8_t crc;
crc = 0;
for(; len; len--)
{
crc ^= *inData++;
crc ^= (crc << 3) ^ (crc << 4) ^ (crc << 6);
crc ^= (crc >> 4) ^ (crc >> 5);
}
return crc;
}

//////////////////////////////////////////////////////
void readTemp(unsigned char* temp, unsigned char device) {
useDevice(device);
sendByte1Wire(READ_SCRATCHPAD);

uint8_t t[ 9 ];
uint8_t crc = 0;

temp[3] = 0;
for ( int8_t i = 0; i < 9 ; ++i )
{
t[ i ] = readByte1Wire();

}
crc = CRC8_2(t, 9);
if ( crc )
{
temp[3] = 1;
} else {
temp[0] = t[0];
temp[1] = t[1];
temp[3] = 2;
}
}
//////////////////////////////////////////////////////

[/syntax]

[syntax=c]
//////////// BIBLIOTEKA OBS�UGI 1 WIRE////////////////
////////////////////////////////AUTOR:JAN G�RSKI//////
////////////////////////////////http://mathmed.blox.pl
#include
#include
#include "1WireLib.h"
//////////////////////////////////////////////////////
//RESET 1 Wire////////////////////////////////////////
unsigned char reset1Wire(void) {
unsigned char counter=12,tmp;
////
SET1WireOut;// DDRX jako wyjscie
PORT1WireOut&=~(1<_delay_us(500); // przynajmniej na 480us, nastepnie
SET1WireIn;// DDRX jako wejscie (ext pullup)
PORT1WireOut|=(1<_delay_us(60);// czekaj 15 - 60 us
while(((PORT1WireIn>>N1Wire)&1) && (counter!=0)) {// sprawdzam, czy pomimo pullup'a magistrala 0
counter--; // i licznik >0
_delay_us(20);// masz 240 us
}
tmp = (PORT1WireIn>>N1Wire)&1;
_delay_us(500);
return !tmp;
}
//////////////////////////////////////////////////////
//Sekwencja slotu/////////////////////////////////////
static void slotSequence() {
SET1WireIn;// ustaw jako wejscie (ext pullup)
_delay_us(2);// przerwa >= 1us
SET1WireOut;// ustaw port jako wyjscie
PORT1WireOut&=~(1<_delay_us(5);// poczekaj <15us
}
//////////////////////////////////////////////////////
//Czyta bit///////////////////////////////////////////
void writeBit(unsigned char bit) {
slotSequence();
_delay_us(5);
if (bit) {// WYSYLAM logiczne 1
SET1WireIn;// zwalniam magistrale (ext pullup)
_delay_us(50);// odczekaj do konca okna transmisji
} else {// WYSYLAM logiczne 0
_delay_us(50);// odczekaj do konca okna transmisji
SET1WireIn;// zwalniam magistrale (ext pullup)
}
}
//Pisze bit///////////////////////////////////////////
char readBit() {
unsigned char counter=5,bit;// potrzebne do osiagniecia max czasu czekania
slotSequence();
SET1WireIn;// jako wejscie...
_delay_us(5);// czas na pullup
while(((PORT1WireIn>>N1Wire)&1) && (counter!=0)) {
_delay_us(2);// czas na pullup
counter--;// pamietajmy, ze "0" jest stanem aktywnym
}
bit=(PORT1WireIn>>N1Wire)&1;
_delay_us(50); // czekanie na koniec okresu odczytywania
return(bit);
}
///////////////////////////////////////////////////////
//Wysylanie Bajtu "data"///////////////////////////////
void sendByte1Wire(unsigned char data) {
unsigned char bit;
for(int i=0;i<8;i++) {// dla kolejnych bitow
bit=data&(1<writeBit(bit);
}
}
//Odczytanie bajtu "data"/////////////////////////////
unsigned char readByte1Wire() {
unsigned char data=0,bit;
for(int i=0;i<8;i++) {// dla kolejnych bitow
bit = readBit();
data|=((bit)<}
return data;
}
///////////////////////////////////////////////////////
//Szuka urzadzen 1Wire i uaktywnia N-te urzadzenie/////
unsigned char useDevice(unsigned char useIt) {
unsigned char bit,bit_complementary,pozycja,buffer[useIt+1];

for(unsigned char i=0;ibuffer[i]=0;
}
for(unsigned char i=0;ipozycja=0;
if(~reset1Wire()&1) return 0;
sendByte1Wire(SEARCH_ROM);
for(unsigned char bitNo=0;bitNo<64;bitNo++) {
bit=readBit();
bit_complementary=readBit();
if ((~(bit|bit_complementary))&1) {
if(buffer[pozycja+1]==0) {
buffer[pozycja]++;
}
writeBit((buffer[pozycja]-1));
pozycja++;
} else {
writeBit(bit);
}
}
while(buffer[pozycja-1]==2) {
buffer[pozycja]=0;
pozycja--;
}
}
return 1;
}
//////////////////////////////////////////////////////
[/syntax]

Kod nie zmieniony praktycznie z oryginału, dodałem tylko co CRC

Pozdrawiam sedecznie

Statystyki: Napisane przez orideith — 26 paź 2012, o 09:57