ATNEL tech-forum 2018-09-15T01:13:29+01:00 https://forum.atnel.pl/feed.php?f=4&t=21269&mode 2018-09-15T01:13:29+01:00 2018-09-15T01:13:29+01:00 https://forum.atnel.pl/viewtopic.php?t=21269&p=211678#p211678 <![CDATA[Re: Atmega 2560 , HC-SR04 Konfiguracja timera]]> Statystyki: Napisane przez weles — 15 wrz 2018, o 01:13

]]> 2018-09-14T18:30:49+01:00 2018-09-14T18:30:49+01:00 https://forum.atnel.pl/viewtopic.php?t=21269&p=211675#p211675 <![CDATA[Re: Atmega 2560 , HC-SR04 Konfiguracja timera]]> // połączenia:
// ECHO1 = PE7
// TRIGGER1 = PE4
// ECHO2 = PL0
// TRIGGER2 = PH4
// sygnał TRIGGER generowany sprzętowo
// wynik obliczany w milimetrach
// obliczenia uwzględniają prawidłowe
// zaokrąglanie wyniku

#define FACTOR1 800000ULL
#define FACTOR2 8552448ULL

#define TRIGGER1_DDR DDRE
#define TRIGGER1_BIT PE4

#define TRIGGER2_DDR DDRH
#define TRIGGER2_BIT PH4

volatile uint16_t echo1_ticks, echo2_ticks;
volatile uint8_t echo1_received, echo2_received;
uint16_t distance1, distance2;

int main(void)
{
// ustawienie pinu OC3B (PE4) jako wyjście
TRIGGER1_DDR |= (1<<TRIGGER1_BIT);
// TIMER 3 - wartość TOP generatora przebiegu
OCR3A = 0xFFFF;
// ustawienie czasu trwania impulsu TRIGGER1
OCR3B = 10;
// TIMER 3 - ustawienie trybu WGM na 'Phase Correct',
// trybu pracy pinu OC3B na "clear when upcounting",
// włączenie taktowania z preskalerem 8,
// ustawienie reakcji ICP3 na zbocze narastające
TCCR3A = (1<<COM3B1) | (1<<WGM31) | (1<<WGM30);
TCCR3B = (1<<ICES3) | (1<<WGM33) | (1<<CS31);
// zezwolenie na przerwanie Input Capture 3
TIMSK3 = (1<<ICIE3);

// ustawienie pinu OC4B (PH4) jako wyjście
TRIGGER2_DDR |= (1<<TRIGGER2_BIT);
// przesunięcie względem poprzedniego timera,
// aby pomiar nie występował w tym samym czasie
TCNT4 = 0xFFF0;
// TIMER 4 - wartość TOP generatora przebiegu
OCR4A = 0xFFFF;
// ustawienie czasu trwania impulsu TRIGGER2
OCR4B = 10;
// TIMER 4 - ustawienie trybu WGM na 'Phase Correct',
// trybu pracy pinu OC4B na "clear when upcounting",
// włączenie taktowania z preskalerem 8,
// ustawienie reakcji ICP4 na zbocze narastające
TCCR4A = (1<<COM4B1) | (1<<WGM41) | (1<<WGM40);
TCCR4B = (1<<ICES4) | (1<<WGM43) | (1<<CS41);
// zezwolenie na przerwanie Input Capture 4
TIMSK4 = (1<<ICIE4);

sei();

while (1)
{
if (echo1_received)
{
distance1 = (uint16_t)( (echo1_ticks * FACTOR1 + FACTOR2 / 2) / FACTOR2 );
echo1_received = 0;
// ewentualne wyświetlenie wyniku
}
PORTL = distance1;
if (echo2_received)
{
distance2 = (uint16_t)( (echo2_ticks * FACTOR1 + FACTOR2 / 2) / FACTOR2 );
echo2_received = 0;
// ewentualne wyświetlenie wyniku
}
}
}


ISR(TIMER3_CAPT_vect)
{
static uint16_t prevICR3 = 0;
if ( !(TCCR3B & (1<<ICES3)) )
{
echo1_ticks = ICR3 - prevICR3;
echo1_received = 1;
}
prevICR3 = ICR3;
TCCR3B ^= (1<<ICES3);
}

ISR(TIMER4_CAPT_vect)
{
static uint16_t prevICR4 = 0;
if ( !(TCCR4B & (1<<ICES4)) )
{
echo2_ticks = ICR4 - prevICR4;
echo2_received = 1;
}
prevICR4 = ICR4;
TCCR4B ^= (1<<ICES4);
}[/syntax]

Statystyki: Napisane przez andrews — 14 wrz 2018, o 18:30

]]> 2018-09-14T14:04:29+01:00 2018-09-14T14:04:29+01:00 https://forum.atnel.pl/viewtopic.php?t=21269&p=211668#p211668 <![CDATA[Re: Atmega 2560 , HC-SR04 Konfiguracja timera]]> Statystyki: Napisane przez weles — 14 wrz 2018, o 14:04

]]> 2018-09-13T20:13:48+01:00 2018-09-13T20:13:48+01:00 https://forum.atnel.pl/viewtopic.php?t=21269&p=211654#p211654 <![CDATA[Re: Atmega 2560 , HC-SR04 Konfiguracja timera]]> Wygląda to tak:

[syntax=c]void init_timer4(void)
{

TCCR4A |= (1 << WGM42)|(1 << WGM43);

TCCR4B |= 1 << CS42 ; // prescaler 256

TIMSK4 |= 1 << OCIE4A | 1 << ICIE4;

TCCR4B |= 1 << ICES4; // Input capture on rising edge

OCR4A = 4031;// PRESCALER 256 - 70ms = 4031 80ms = 4607


// 70ms cycle: 14745600 / 256 = 57600 counts/second => 57600/10 = 5760 counts/100ms => 5760/100*70 = 4032 counts / 70ms


//us_per_count = 164; // 14745600/256 = 57600 counts/second => 14745600/57600
us_per_count =164 ;
}[/syntax]


[syntax=c]ISR (TIMER4_CAPT_vect)
{

if (TCCR4B & (1<<ICES4)) // On rising edge
{
TCCR4B &= ~(1<<ICES4); // Next time detect falling edge
rising = ICR4; // Save current count
}
else // On falling edge
{
TCCR4B |= (1<<ICES4); // Next time detect falling edge
falling = ICR4; // Save current count
counts = (uint32_t)falling - (uint32_t)rising;
dist = (uint32_t)us_per_count * counts / 58; // useconds / 58 to get distance in cm
}

}//ISR (TIMER4_CAPT_vect)




ISR (TIMER4_COMPA_vect)
{
TRIG1_PORT |= HC_TRIG1;
TRIG2_PORT |= HC_TRIG2;
_delay_us(10);
TRIG1_PORT &= ~HC_TRIG1;
TRIG2_PORT &= ~HC_TRIG2;
}[/syntax]

Tylko teraz muszę jeszcze obsłużyć drugi HC-SR05.
Pierwszy czujnik obsługuję z pinu ICP4 (pin 49). Drugi mam podpięte pod ICP5.
Proszę o jakąś poradę jak tego dokonać nie rozbudowując niepotrzebnie zbytnio kodu.
Z resztą już sobie poradzę.

Statystyki: Napisane przez weles — 13 wrz 2018, o 20:13

]]> 2018-09-11T22:31:39+01:00 2018-09-11T22:31:39+01:00 https://forum.atnel.pl/viewtopic.php?t=21269&p=211584#p211584 <![CDATA[Re: Atmega 2560 , HC-SR04 Konfiguracja timera]]>
A przy tym kodzie pomiar na jednym czujniku działa ale nie zgadza się odległość. Niby ma być wynik w CM a jest w milimetrach. Ale i tak nieco się różni od rzeczywistego.

[syntax=c]void init_timer4()
{
/**
* https://s30.postimg.org/ahb62cb01/Wavefrom_Generation_Mode_Bit_Description.jpg
*/
TCCR4A |= (1 << WGM41);
/**
* https://s27.postimg.org/k2tu225pf/Clock_Select_Bit_Description.jpg
**/

TCCR4B |= 1 << CS42 ; // prescaler 256

TIMSK4 |= 1 << OCIE4A | 1 << ICIE4;
/**
* ICIE: Input Capture Interrupt Enable
When this bit is written to '1', and the I-flag in the Status Register is set (interrupts globally enabled), the
Timer/Counter1 Input Capture interrupt is enabled. The corresponding Interrupt Vector is executed when
the ICF Flag, located in TIFR1, is set.

When a capture is triggered according to the ICESn setting, the counter value is copied into the Input Capture Register
(ICRn). The event will also set the Input Capture Flag (ICFn), and this can be used to cause an Input Capture
Interrupt, if this interrupt is enabled.

When the ICRn is used as TOP value (see description of the WGMn3:0 bits located in the TCCRnA and the
TCCRnB Register), the ICPn is disconnected and consequently the input capture function is disabled.
*/

/* ICP4 (Input Capture Interrupt) , DIGITAL PIN 49
* ISR(TIMER4_CAPT_vect) when the signal on the ICP pin goes from 0 to 1 (raising edge).
* The method contains a if stament to see if it was called during a raising edge or falling edge.
* On a raising edge it switches the ICP to falling edge detection and then stores the start time.
* On a falling edge it switches the ICP to raising edge detection and gets the end time to calculate the distance in millimeters.
*/
TCCR4B |= 1 << ICES4; // Input capture on rising edge

/**
* This bit selects which edge on the Input Capture pin (ICP1) that is used to trigger a capture event. When
the ICES1 bit is written to zero, a falling (negative) edge is used as trigger, and when the ICES1 bit is
written to '1', a rising (positive) edge will trigger the capture.
When a capture is triggered according to the ICES1 setting, the counter value is copied into the Input
Capture Register (ICR1). The event will also set the Input Capture Flag (ICF1), and this can be used to
cause an Input Capture Interrupt, if this interrupt is enabled.
When the ICR1 is used as TOP value (see description of the WGM1[3:0] bits located in the TCCR1A and
the TCCR1B Register), the ICP1 is disconnected and consequently the Input Capture function is
disabled.
*/
// OCR4A = 8750;
OCR4A = 4608;
// "we suggest to use over 60ms measurement cycle, in order to prevent trigger signal to the echo signal."
// source: http://www.robosoftsystems.co.in/wikidocs/index.php?title=Ultrasonic_Sensor_(HC-SR04)
// 70ms cycle: 8MHz/64 = 125000 counts/second => 125000/10 = 12500 counts/100ms => 12500/100*70 = 8750 counts / 70ms

// 80ms cycle: 14745600/256 = 57600 counts/second => 57600/10 = 5760 counts/100ms => 5760/100*80 = 4608 counts / 80ms
sei();
//us_per_count = 4; // 8MHz / 64 = 125000 counts/second => 1000000/125000
//us_per_count = 164; // 14745600/256 = 57600 counts/second => 14745600/57600
us_per_count = 128;
}[/syntax]


[syntax=c]ISR (TIMER4_CAPT_vect)
{
/* Input Capture Unit
* https://s23.postimg.org/gumgo0sln/Input_Capture_Unit.jpg
*/
if (TCCR4B & (1<<ICES4)) // On rising edge
{
TCCR4B &= ~(1<<ICES4); // Next time detect falling edge
rising = ICR4; // Save current count
}
else // On falling edge
{
TCCR4B |= (1<<ICES4); // Next time detect falling edge
falling = ICR4; // Save current count
counts = (uint32_t)falling - (uint32_t)rising;
dist = (uint32_t)us_per_count * counts / 58; // useconds / 58 to get distance in cm

}

}//ISR (TIMER4_CAPT_vect)




ISR (TIMER4_COMPA_vect)
{
TRIG1_PORT |= HC_TRIG1;
_delay_us(12);
TRIG1_PORT &= ~HC_TRIG1;
}[/syntax]


Według metody prób i błędów problem w dużej mierze tkwi tutaj:

[syntax=c]OCR4A = 4608;[/syntax]

Liczba 4608 wychodzi mi z obliczenia cyklu 80ms dla odczytu.

80ms cycle: 14745600/256 = 57600 counts/second => 57600/10 = 5760 counts/100ms => 5760/100*80 = 4608 counts / 80ms

Producent zaleca powyżej 60ms.

Dodatkowo kolejny błąd tkwi tutaj. Ma to kluczowe znaczenie przy końcowym wyliczeniu odległości.
Teoretycznie powinno to wyglądać tak:

us_per_count = 128; // 14745600/256 = 57600 counts/second => 14745600/57600

Ale w miarę zbliżony do prawdziwego wyniku pomiaru odległości muszę wprowadzić wartość

us_per_count = 164;

Statystyki: Napisane przez weles — 11 wrz 2018, o 22:31

]]> 2018-09-11T22:17:58+01:00 2018-09-11T22:17:58+01:00 https://forum.atnel.pl/viewtopic.php?t=21269&p=211583#p211583 <![CDATA[Re: Atmega 2560 , HC-SR04 Konfiguracja timera]]> nie wiem skąd wziąłeś to
[syntax=c]TCCR4B |= 1 << ICES5;[/syntax]
mieszasz rejestry i numery timerów
dla timera4 powinno być
[syntax=c]TCCR4B |=(1<<ICES4);
TCCR4B |=(1<<CS41);
TIMSK4 |=(1<<TOIE4);[/syntax]
i spróbuj z jednym czujnikiem a jak zadziała to pójdziemy dalej

Statystyki: Napisane przez mczarny — 11 wrz 2018, o 22:17

]]> 2018-09-11T20:19:24+01:00 2018-09-11T20:19:24+01:00 https://forum.atnel.pl/viewtopic.php?t=21269&p=211580#p211580 <![CDATA[Re: Atmega 2560 , HC-SR04 Konfiguracja timera]]> Ja potrzebuję mierzyć czas w mikrosekundach poprzez wejścia timera ICP
Zacznijmy od tego że potrzebuję przerwania od ICP.

Czyli (jeśli chodzi o kod z Atmega 32) powinno to wyglądać tak:
[syntax=c]TIMSK |= (1<<TICIE1);[/syntax]

ale ja używam M2560.


Znalazłem przykład dla M2560 i Timera4 na Avrfreaks (z tym że dla kwarcu 1MHz)

[syntax=c]void init_timer4()
{

/**
* https://s27.postimg.org/k2tu225pf/Clock_Select_Bit_Description.jpg
**/
TCCR4A |= (1 << WGM41);
TCCR4B |= 1 << CS41; // prescaler 8

TIMSK4 |= 1 << OCIE4A | 1 << ICIE4;
/**
* ICIE: Input Capture Interrupt Enable
When this bit is written to '1', and the I-flag in the Status Register is set (interrupts globally enabled), the
Timer/Counter1 Input Capture interrupt is enabled. The corresponding Interrupt Vector is executed when
the ICF Flag, located in TIFR1, is set.

When a capture is triggered according to the ICESn setting, the counter value is copied into the Input Capture Register
(ICRn). The event will also set the Input Capture Flag (ICFn), and this can be used to cause an Input Capture
Interrupt, if this interrupt is enabled.

When the ICRn is used as TOP value (see description of the WGMn3:0 bits located in the TCCRnA and the
TCCRnB Register), the ICPn is disconnected and consequently the input capture function is disabled.
*/

/* ICP4 (Input Capture Interrupt) , DIGITAL PIN 49
* ISR(TIMER4_CAPT_vect) when the signal on the ICP pin goes from 0 to 1 (raising edge).
* The method contains a if stament to see if it was called during a raising edge or falling edge.
* On a raising edge it switches the ICP to falling edge detection and then stores the start time.
* On a falling edge it switches the ICP to raising edge detection and gets the end time to calculate the distance in millimeters.
*/
TCCR4B |= 1 << ICES4; // Input capture on rising edge
/**
* This bit selects which edge on the Input Capture pin (ICP1) that is used to trigger a capture event. When
the ICES1 bit is written to zero, a falling (negative) edge is used as trigger, and when the ICES1 bit is
written to '1', a rising (positive) edge will trigger the capture.
When a capture is triggered according to the ICES1 setting, the counter value is copied into the Input
Capture Register (ICR1). The event will also set the Input Capture Flag (ICF1), and this can be used to
cause an Input Capture Interrupt, if this interrupt is enabled.
When the ICR1 is used as TOP value (see description of the WGM1[3:0] bits located in the TCCR1A and
the TCCR1B Register), the ICP1 is disconnected and consequently the Input Capture function is
disabled.
*/
OCR4A = 8750;
// "we suggest to use over 60ms measurement cycle, in order to prevent trigger signal to the echo signal."
// source: http://www.robosoftsystems.co.in/wikidocs/index.php?title=Ultrasonic_Sensor_(HC-SR04)
// 70ms cycle: 1MHz/8 = 125000 counts/second => 125000/10 = 12500 counts/100ms => 12500/100*70 = 8750 counts / 70ms
sei();
us_per_count = 8; // 1MHz / 8 = 125000 counts/second => 1000000/125000

}[/syntax]

W zasadzie mogę użyć Timera4 ale muszę dopasować go do mojego kwarcu czyli 14745600.
Dodatkowo nie do końca rozumiem jak mam obsłużyć dwa moduły HC-SR04 odczytywane z pinów ICP4 i ICP5.

Czy chodzi o to:

[syntax=c]TCCR4B |= 1 << ICES4; // Input capture on rising edge[/syntax]

i dla drugiego pinu ICP powinienem ustawić to w taki sposób ?

[syntax=c]TCCR4B |= 1 << ICES5; // Input capture on rising edge[/syntax]


Jeśli to dobrze rozumiem to odczyt dla ICP4 powinien wyglądać tak:

[syntax=c]ISR (TIMER4_CAPT_vect)
{
/* Input Capture Unit
*/
if (TCCR4B & (1<<ICES4)) // On rising edge
{
TCCR4B &= ~(1<<ICES1); // Next time detect falling edge
rising = ICR1; // Save current count
}
else // On falling edge
{
TCCR4B |= (1<<ICES4); // Next time detect falling edge
falling = ICR4; // Save current count
counts = (uint32_t)falling - (uint32_t)rising;
dist = (uint32_t)us_per_count * counts/ 58; // useconds / 58 to get distance in cm
ready_to_print = 1;
}
}[/syntax]

Statystyki: Napisane przez weles — 11 wrz 2018, o 20:19

]]> 2018-09-10T06:45:52+01:00 2018-09-10T06:45:52+01:00 https://forum.atnel.pl/viewtopic.php?t=21269&p=211520#p211520 <![CDATA[Re: Atmega 2560 , HC-SR04 Konfiguracja timera]]> ta linijka jest błądna
[syntax=c]TIMSK3 |= (1<<ICIE3 );[/syntax]
powinno być
[syntax=c]TIMSK3 |=(1<<OCIE3A);[/syntax]
No i nie masz ustawionego trybu pracy timera
Obrazek
jeżeli chcesz tryb CTC to bit WGM32 w rejestrze TCCR3B
Zapoznaj się z notą kontrolera tam masz wszystko
[syntax=c]TCCR3B |= (1<<WGM32);
TCCR3B |= (1<<CS31);
OCR0A = 100;
TIMSK3 |= (1<<OCIE3A);[/syntax]
przykładowo można tak zależy co ile chcesz przerwanie

Statystyki: Napisane przez mczarny — 10 wrz 2018, o 06:45

]]> 2018-09-09T21:36:31+01:00 2018-09-09T21:36:31+01:00 https://forum.atnel.pl/viewtopic.php?t=21269&p=211518#p211518 <![CDATA[Atmega 2560 , HC-SR04 Konfiguracja timera]]> Nadeszła w moim projekcie pora na uruchomienie pomiarów z dwóch modułów HC-SR04.
Kiedy wcześniej testowałem działanie na Atmega32 i zastosowaniu kodu z poradnika Mirka wszystko działało poprawnie.
Ale teraz używam Atmega 2560 i nie jest już tak prosto. Nie dość że to inny mikrokontroler to do tego muszę użyć dwóch modułów HC.

Piny jakich używam do modułów HC to :

[syntax=c]//L0-HC1
#define HC_ECHO1(1<<PL0)
#define ECHO1_PORTPORTL
#define ECHO1_DIRDDRL
//L1HC2
#define HC_ECHO2(1<<PL1)
#define ECHO2_PORTPORTL
#define ECHO2_DIRDDRL
//L2-HC1
#define HC_TRIG1(1<<PL2)
#define TRIG1_PORTPORTL
#define TRIG1_DIRDDRL
//L3-HC2
#define HC_TRIG2(1<<PL3)
#define TRIG2_PORTPORTL[/syntax]


[syntax=c]//L0-
ECHO1_PORT |= HC_ECHO1;
//L1-
ECHO2_PORT |= HC_ECHO2;
//L2-
TRIG1_DIR |= HC_TRIG1;
//L3-
TRIG2_DIR |= HC_TRIG2;[/syntax]

Gdzie piny mikrokontrolera L0 i L1 to ICP.

Wydaje mi się że problemem jest tu konfiguracja timera.
Do dyspozycji mam sprzętowy Timer3.
Robię to tak:

[syntax=c]//7.***** TIMER3 - TRYB ICP - DALMIERZ *******
TCCR3B |= (1<<ICES3);//zbocze narastające
TCCR3B |= (1<<CS31);// ustawienie prescalera na 8
TIMSK3 |= (1<<ICIE3 );// odblokowanie przerwania[/syntax]

I zapewne pierwszy błąd znajduje się właśnie tu. Bo o ile preskaler i zbocze potrafię ustawić to problemem jest odblokowanie przerwania.
Zwyczajnie nie wiem jak powinienem zabrać się za obsługę dwóch modułów. W sumie na tym mikrokontrolerze nawet jednego nie potrafię uruchomić :/

Może znajdzie się wśród kolegów i koleżanek ktoś kto zechciałby nieco mi pomóc w tej kwestii.
Chciałbym w pierwszej kolejności poprawnie ustawić timer i dokonać odczytu z jednego modułu HC. Potem przyjdzie pora na kolejny.

Statystyki: Napisane przez weles — 9 wrz 2018, o 21:36

]]>