ATNEL tech-forum 2019-08-13T12:14:08+01:00 https://forum.atnel.pl/feed.php?f=4&t=22487&mode 2019-08-13T12:14:08+01:00 2019-08-13T12:14:08+01:00 https://forum.atnel.pl/viewtopic.php?t=22487&p=221230#p221230 <![CDATA[Re: Odliczanie czasu działania programu ATMEGA8]]> Podane przykłady jak stosować timer nie rozwiązują jeszcze powyższego założenia.
Jeżeli jest błąd czujki to należy doprowadzić do wyłączenia sterownika, tak by nie reagował w ogóle na czujkę a wręcz sygnalizował stan awarii, który wymaga ręcznego resetu przez autora sterownika lub naprawy czujki.
Czyli np. po przekroczeniu krytycznego czasu podawania ciągłego sygnału przez czujki następuje wyłączenie wszystkich LED od oświetlenia schodów oraz blokowany jest port lub piny przychodzącego sygnału od czujki i ewentualnie zapalenie jakiejś dodatkowej diody LED sygnalizującej stan awarii.

Statystyki: Napisane przez JarekK — 13 sie 2019, o 12:14

]]> 2019-08-13T11:49:51+01:00 2019-08-13T11:49:51+01:00 https://forum.atnel.pl/viewtopic.php?t=22487&p=221227#p221227 <![CDATA[Re: Odliczanie czasu działania programu ATMEGA8]]> Aby to zrobic należy:
dodać plik nagłówkowy interrupt.h (#include <avr/interrupt.h>)
uruchomic timer[syntax=c]TIMSK |= (1<<TOIE0);
TCCR0 |= (1<<CS02) | (1<<CS00);
sei();/[/syntax]
dodać obsługę przerwania timera, np. taką[syntax=c]ISR(TIMER0_OVF_vect)
{
static uint8_t tick=0;
tick++;
if(tick>122)
{
//tu gaszenie led
tick=0;
}[/syntax]
wartość 122 w if() jest "z rękawa". Nie wiem z jaka częstotliwością pracuje u Ciebie Atmega. Dla 8MHz przerwanie be4dzie wykonywać się z częstotliwością
8000000/(1024*256)=30,5Hz, a if wykona sie co ok 4s. Uzyskanie dłuższych czasów nie powinno być już dla Ciebie problemem.
Przerwanie odliczania czasu też nie powinno sprawić kłopotu. Można wyzerować zmienną tick.
I jeszcze mała uwaga. warto sekwencje zapalania i gaszenia led umi4eścić w odpowiednich funkcjach,. wtedy analiza kodu będzie znacznie prostsza.

Statystyki: Napisane przez Alef2 — 13 sie 2019, o 11:49

]]> 2019-08-13T11:45:09+01:00 2019-08-13T11:45:09+01:00 https://forum.atnel.pl/viewtopic.php?t=22487&p=221226#p221226 <![CDATA[Re: Odliczanie czasu działania programu ATMEGA8]]> Jak chcesz mieć możliwość łatwej zmiany czasu bez przerabiania kodu zdefiniuj te wartości poleceniem #define
czyli zamiast
[syntax=c]int a;
int b;
int c;
a = 250;
b = 1000;
c = 350;[/syntax]
użyj czegoś takiego
[syntax=c]#define CZAS_A 250
#define CZAS_B 1000
#define CZAS_C 350

//i wtedy w dalayach
_delay_ms(CZAS_A);[/syntax]
Takie rozwiązanie zadziała zawsze i nie zajmie pamięci ram procesora.

Wracając do tematu to musisz uruchomić tejmer sprzętowy który atmega8 posiada w ilości 3 na swoim wyposażeniu, proponuję timer1 bo na nim najwygodniej dostosować czas, a i tak leży odłogiem.
Włączasz przerwanie od porównania timera i ustawiasz timer tak by generował przerwanie co powiedzmy 1s.
W programie tworzysz zmienną, to będzie licznik sekund zliczający do 300 (czyli twoje 5minut świecenia).
Zmienna powinna być opatrzona jako volatile oraz powinna być 16 bitowa:
[syntax=c]volatile uint16_t licznik;[/syntax]
W obsłudze przerwania wstawiasz coś w tym stylu:
[syntax=c]if(licznik>1) licznik--;[/syntax]
a w pętli głównej dodajesz warunek:
[syntax=c]if(licznik==1){
//instrukcja zgaś ledy;
licznik=0;
}[/syntax]
Na koniec w warunkach zapalających ledy ładujesz licznik na zadany czas czyli nasze 300.
I teraz w momencie gdy czujka zainicjuje zapalenie ledów, załaduje również licznik. Tykające przerwanie ten licznik będzie co sekundę zmniejszało o 1. Gdy licznik dojdzie do 1 odliczanie się zatrzyma, równocześnie spełniony zostanie warunek w głównej pętli programu odpowiedzialny za natychmiastowe zgaszenie ledów, jednocześnie licznik zostanie wyzerowany i cały mechanizm zdezaktywowany)
Dla porządku możesz w warunku stopniowego gaszenia również wyzerować licznik by mechanizm bezwarunkowego gaszenie nie wywoływał się gdy ledy już wcześniej zostały wygaszone przez czujkę.
To chyba tyle. Mam nadzieję że coś zrozumiesz i sobie poradzisz. Ewentualnie dopytaj.

Statystyki: Napisane przez xentis — 13 sie 2019, o 11:45

]]> 2019-08-13T10:06:26+01:00 2019-08-13T10:06:26+01:00 https://forum.atnel.pl/viewtopic.php?t=22487&p=221222#p221222 <![CDATA[Re: Odliczanie czasu działania programu ATMEGA8]]> xentis napisał(a):

Quote:
I nie proszę tutaj "Panowie, zróbcie mi ten program tak by było dobrze", tylko o jakiekolwiek wskazówki
widzisz, piszesz że nie masz czasu na naukę programowania, to jak ktoś ma Ci dać wskazówki skoro prawdopodobnie bez douczenie nie będziesz w stanie ich wykorzystać?
Ale ok, mogę spróbować Ci pomóc tylko jeszcze musisz uzupełnić założenia. Ten timer po odliczeniu ma wyłączyć ledy i zablokować ich zapalanie na jakiś czas, czy do resetu czy jeszcze jakoś inaczej?



Masz rację, jednak gdybym otrzymał jakąś wskazówkę, to jakby zakres poszukiwań rozwiązania by się diametralnie zawęził, bo doskonale wiem, że programowania nie da się nauczyć w tydzień czy miesiąc. Bardzo dziękuję za litość ;) Timer po odliczeniu ma wyłączyć po prostu zapalone ledy - jeżeli nie są zapalone to odliczanie nie ma być realizowane. Nie ma blokować ich zapalenia, ten timer ma wyłączać ledy po to, gdyby np. ledy same się zapaliły przez błąd czujki, żeby nie świeciły cały dzień gdy nie ma mnie w domu.

Statystyki: Napisane przez kozak0211 — 13 sie 2019, o 10:06

]]> 2019-08-13T08:04:48+01:00 2019-08-13T08:04:48+01:00 https://forum.atnel.pl/viewtopic.php?t=22487&p=221221#p221221 <![CDATA[Re: Odliczanie czasu działania programu ATMEGA8]]> Quote:

I nie proszę tutaj "Panowie, zróbcie mi ten program tak by było dobrze", tylko o jakiekolwiek wskazówki
widzisz, piszesz że nie masz czasu na naukę programowania, to jak ktoś ma Ci dać wskazówki skoro prawdopodobnie bez douczenie nie będziesz w stanie ich wykorzystać?
Ale ok, mogę spróbować Ci pomóc tylko jeszcze musisz uzupełnić założenia. Ten timer po odliczeniu ma wyłączyć ledy i zablokować ich zapalanie na jakiś czas, czy do resetu czy jeszcze jakoś inaczej?

Statystyki: Napisane przez xentis — 13 sie 2019, o 08:04

]]> 2019-08-12T17:08:46+01:00 2019-08-12T17:08:46+01:00 https://forum.atnel.pl/viewtopic.php?t=22487&p=221207#p221207 <![CDATA[Re: Odliczanie czasu działania programu ATMEGA8]]>
Jeśli masz BB to gotowiec jest na stronie od 326 do 329.
Pisząc gotowiec mam na myśli że jest tam pokazane jak się do tego
zabrać :D :D

Statystyki: Napisane przez michu — 12 sie 2019, o 17:08

]]> 2019-08-12T14:12:20+01:00 2019-08-12T14:12:20+01:00 https://forum.atnel.pl/viewtopic.php?t=22487&p=221203#p221203 <![CDATA[Re: Odliczanie czasu działania programu ATMEGA8]]>
I ja rozumiem, że ktoś nie chce się uczyć podstaw programowania - ja mam tak samo np z linuxem - już się go nie nauczę w życiu, a próbowałem - tyle że czasu nie starcza aby dalej się uczyć - ale też nie rzucam się wtedy na linuxa - no bo jak ? ;)

Statystyki: Napisane przez mirekk36 — 12 sie 2019, o 14:12

]]> 2019-08-12T13:59:13+01:00 2019-08-12T13:59:13+01:00 https://forum.atnel.pl/viewtopic.php?t=22487&p=221202#p221202 <![CDATA[Re: Odliczanie czasu działania programu ATMEGA8]]> mirekk36 napisał(a):

To ja ci tylko podpowiem, że warto zacząć od tej książki:

https://atnel.pl/mikrokontrolery-avr-jezyk-c.html

bo te dwa jak je nazwałeś "programy" ciężko nazwać programami - szczególnie ten pierwszy .... Ok ja rozumiem, że zaczynasz - no ale ... warto jednak zrobić krok naprzód - bo w ten sposób nigdy nie pisze się programów a ich łączenie - to po prostu istna mordęga


Z całym szacunkiem dla Ciebie Mirku, ale już wybrałem inny kierunek w swojej karierze, a programowanie dla mnie jest bardzo czasochłonne - nie posiadam niestety tyle czasu, by rozpocząć naukę od podstaw. Doskonale zdaję sobie sprawę, że aż oczy bolą jak się widzi takie programowe herezje, jednak dla mnie najważniejszą rzeczą jest to, że ten program mimo wszystko działa jak należy, chciałem tylko zastosować ten timer w jednym programie, ponieważ ATTiny przestał działać. Spodziewałem się, że nie jest to jakaś trudna sprawa dla doświadczonego programisty. I nie proszę tutaj "Panowie, zróbcie mi ten program tak by było dobrze", tylko o jakiekolwiek wskazówki, ale jeżeli mówisz, że zastosowanie timera w programie głównym to istna mordęga, to rzeczywiście tak musi być.

Statystyki: Napisane przez kozak0211 — 12 sie 2019, o 13:59

]]> 2019-08-12T13:33:44+01:00 2019-08-12T13:33:44+01:00 https://forum.atnel.pl/viewtopic.php?t=22487&p=221201#p221201 <![CDATA[Re: Odliczanie czasu działania programu ATMEGA8]]>
https://atnel.pl/mikrokontrolery-avr-jezyk-c.html

bo te dwa jak je nazwałeś "programy" ciężko nazwać programami - szczególnie ten pierwszy .... Ok ja rozumiem, że zaczynasz - no ale ... warto jednak zrobić krok naprzód - bo w ten sposób nigdy nie pisze się programów a ich łączenie - to po prostu istna mordęga

Statystyki: Napisane przez mirekk36 — 12 sie 2019, o 13:33

]]> 2019-08-12T13:23:29+01:00 2019-08-12T13:23:29+01:00 https://forum.atnel.pl/viewtopic.php?t=22487&p=221200#p221200 <![CDATA[Odliczanie czasu działania programu ATMEGA8]]>
Od razu mówię, że nie jestem profesjonalistą w dziedzinie programowania w języku C, dlatego też proszę o pomoc. Kilka lat temu napisałem program na ATMEGA8 realizujący sekwencyjne zapalanie ledów, umieszczonych w stopniach schodowych. Program ten jest uruchamiany za pomocą 2 czujek podających stan wysoki, gdy wykryją ruch. Miałem wtedy problem z jedną rzeczą:

"co zrobić, gdy ledy zapalą się samoczynnie przez np. błąd czujki i program będzie realizowany bez przerwy?"

Chciałem napisać tzw. timer do tego programu, który by odliczał czas np. "jeżeli ledy świecą ponad 5 minut, wyłącz", jednak nie wiedziałem jak to zlepić wszystko do kupy by trybiło w jednym, spójnym programie. Dlatego zastosowałem drugi mikrokontroler ATTiny, który odliczał czas i gdy minęło załóżmy 5 minut, podawał stan wysoki na jedną z nóżek, która natomiast była przylutowana do pinu wejścia ATMEGA8. Dzięki temu ATMEGA8 otrzymując stan wysoki od ATTIny na wejście realizowała sekwencje gaszenia ledów.

Wiem, że jest to durna realizacja, bo jestem pewien, że da się to zaimplementować po prostu w programie i wystarczyłaby sama ATMEGA8, jednak nie mam pojęcia jak tego dokonać, dlatego proszę o wskazówki. Poniżej wstawiam obydwa programy (ATMEGA8 i ATTiny).

Główny program na ATMEGA8 realizujący zapalanie/gaszenie ledów schodowych

[syntax=csharp]#include <avr/io.h>
#include <util/delay.h>

int main(void)
{
//Port B i D jako wyjścia
DDRB = 0XFF;
DDRD = 0XFF;
//Stan niski na wyjściach
PORTB = 0X00;
PORTD = 0X00;
//Port C jako wejścia
DDRC = 0x00;
//wejścia podciągnięte do GND (PRZYCISK TEST "PC5" DO VCC!)
PORTC = 0x20;
//inicjowanie zmiennych ustalających opóźnienie czasowe
int a;
int b;
int c;
a = 250;
b = 1000;
c = 350;
//Początek nieskończonej pętli
while(1)
{
//Jeżeli na PINC1 podany zostanie stan wysoki
if(PINC & 0X02)
{
PORTB = 0XFE;
PORTD = 0X7F;
_delay_ms(a);
PORTB = 0XFC;
PORTD = 0X3F;
_delay_ms(a);
PORTB = 0XF8;
PORTD = 0X1F;
_delay_ms(a);
PORTB = 0XF0;
PORTD = 0X0F;
_delay_ms(a);
PORTB = 0XE0;
PORTD = 0X07;
_delay_ms(a);
PORTB = 0XC0;
PORTD = 0X03;
_delay_ms(a);
PORTB = 0X80;
PORTD = 0X01;
_delay_ms(a);
PORTB = 0X00;
PORTD = 0x00;
}
// jeżeli na PINC3 padany zostanie stan wysoki
if(PINC & 0X08)
{ _delay_ms(0);
if(PORTB == 0) // jeżeli schody wygaszone, świeć
{
//sekwencja zapalania schodów od punktu A do punktu B
PORTB = 0X01;
PORTD = 0X00;
_delay_ms(a);
PORTB = 0X03;
PORTD = 0X00;
_delay_ms(a);
PORTB = 0X07;
PORTD = 0X00;
_delay_ms(a);
PORTB = 0X0F;
PORTD = 0X00;
_delay_ms(a);
PORTB = 0X1F;
PORTD = 0X00;
_delay_ms(a);
PORTB = 0X3F;
PORTD = 0X00;
_delay_ms(a);
PORTB = 0X7F;
PORTD = 0X00;
_delay_ms(a);
PORTB = 0XFF;
PORTD = 0X00;
_delay_ms(a);
PORTB = 0XFF;
PORTD = 0X01;
_delay_ms(a);
PORTB = 0XFF;
PORTD = 0X03;
_delay_ms(a);
PORTB = 0XFF;
PORTD = 0X07;
_delay_ms(a);
PORTB = 0XFF;
PORTD = 0X0F;
_delay_ms(a);
PORTB = 0XFF;
PORTD = 0X1F;
_delay_ms(a);
PORTB = 0XFF;
PORTD = 0X3F;
_delay_ms(a);
PORTB = 0XFF;
PORTD = 0X7F;
_delay_ms(a);
PORTB = 0XFF;
PORTD = 0XFF;
_delay_ms(100);
}
else //jeżeli schody zapalone, gaś
{
//sekwencja wygaszania schodów od puntku B do punktu A

_delay_ms(6000);
PORTB = 0XFF;
PORTD = 0XFF;
_delay_ms(c);
PORTB = 0XFF;
PORTD = 0X7F;
_delay_ms(c);
PORTB = 0XFF;
PORTD = 0X3F;
_delay_ms(c);
PORTB = 0XFF;
PORTD = 0X1F;
_delay_ms(c);
PORTB = 0XFF;
PORTD = 0X0F;
_delay_ms(c);
PORTB = 0XFF;
PORTD = 0X07;
_delay_ms(c);
PORTB = 0XFF;
PORTD = 0X03;
_delay_ms(c);
PORTB = 0XFF;
PORTD = 0X01;
_delay_ms(c);
PORTB = 0XFF;
PORTD = 0X00;
_delay_ms(c);
PORTB = 0X7F;
PORTD = 0X00;
_delay_ms(c);
PORTB = 0X3F;
PORTD = 0X00;
_delay_ms(c);
PORTB = 0X1F;
PORTD = 0X00;
_delay_ms(c);
PORTB = 0X0F;
PORTD = 0X00;
_delay_ms(c);
PORTB = 0X07;
PORTD = 0X00;
_delay_ms(c);
PORTB = 0X03;
PORTD = 0X00;
_delay_ms(c);
PORTB = 0X01;
PORTD = 0X00;
_delay_ms(c);
PORTB = 0X00;
PORTD = 0X00;
_delay_ms(4000);
}
}

if(PINC & 0X10) //Jeżeli na PINC4 podany zostanie stany wysoki
{_delay_ms(0);
if(PORTB == 0) //Jeżeli schody wygaszone, świeć
{
//sekwencja świecenia schodów od punktu B do punktu A
PORTB = 0X00;
PORTD = 0X80;
_delay_ms(a);
PORTB = 0X00;
PORTD = 0XC0;
_delay_ms(a);
PORTB = 0X00;
PORTD = 0XE0;
_delay_ms(a);
PORTB = 0X00;
PORTD = 0XF0;
_delay_ms(a);
PORTB = 0X00;
PORTD = 0XF8;
_delay_ms(a);
PORTB = 0X00;
PORTD = 0XFC;
_delay_ms(a);
PORTB = 0X00;
PORTD = 0XFE;
_delay_ms(a);
PORTB = 0X00;
PORTD = 0XFF;
_delay_ms(a);
PORTB = 0X80;
PORTD = 0XFF;
_delay_ms(a);
PORTB = 0XC0;
PORTD = 0XFF;
_delay_ms(a);
PORTB = 0XE0;
PORTD = 0XFF;
_delay_ms(a);
PORTB = 0XF0;
PORTD = 0XFF;
_delay_ms(a);
PORTB = 0XF8;
PORTD = 0XFF;
_delay_ms(a);
PORTB = 0XFC;
PORTD = 0XFF;
_delay_ms(a);
PORTB = 0XFE;
PORTD = 0XFF;
_delay_ms(a);
PORTB = 0XFF;
PORTD = 0XFF;
_delay_ms(100);
}
else //jeżeli schody zapalone, gaś
{
//sekwencja gaszenia schodów od punktu A do punktu B

_delay_ms(6000);
PORTB = 0XFE;
PORTD = 0XFF;
_delay_ms(c);
PORTB = 0XFC;
PORTD = 0XFF;
_delay_ms(c);
PORTB = 0XF8;
PORTD = 0XFF;
_delay_ms(c);
PORTB = 0XF0;
PORTD = 0XFF;
_delay_ms(c);
PORTB = 0XE0;
PORTD = 0XFF;
_delay_ms(c);
PORTB = 0XC0;
PORTD = 0XFF;
_delay_ms(c);
PORTB = 0X80;
PORTD = 0XFF;
_delay_ms(c);
PORTB = 0X00;
PORTD = 0XFF;
_delay_ms(c);
PORTB = 0X00;
PORTD = 0XFE;
_delay_ms(c);
PORTB = 0X00;
PORTD = 0XFC;
_delay_ms(c);
PORTB = 0X00;
PORTD = 0XF8;
_delay_ms(c);
PORTB = 0X00;
PORTD = 0XF0;
_delay_ms(c);
PORTB = 0X00;
PORTD = 0XE0;
_delay_ms(c);
PORTB = 0X00;
PORTD = 0XC0;
_delay_ms(c);
PORTB = 0X00;
PORTD = 0X80;
_delay_ms(c);
PORTB = 0X00;
PORTD = 0X00;
_delay_ms(4000);
}

}

//program testujący (Przycisk TEST)

if(!(PINC & 0X20)) //jeżli podany zostanie stan niski na PINC5
{
//sekwencja zapalania od punktu A do B
_delay_ms(100);
PORTB = 0X01;
PORTD = 0X00;
_delay_ms(a);
PORTB = 0X03;
PORTD = 0X00;
_delay_ms(a);
PORTB = 0X07;
PORTD = 0X00;
_delay_ms(a);
PORTB = 0X0F;
PORTD = 0X00;
_delay_ms(a);
PORTB = 0X1F;
PORTD = 0X00;
_delay_ms(a);
PORTB = 0X3F;
PORTD = 0X00;
_delay_ms(a);
PORTB = 0X7F;
PORTD = 0X00;
_delay_ms(a);
PORTB = 0XFF;
PORTD = 0X00;
_delay_ms(a);
PORTB = 0XFF;
PORTD = 0X01;
_delay_ms(a);
PORTB = 0XFF;
PORTD = 0X03;
_delay_ms(a);
PORTB = 0XFF;
PORTD = 0X07;
_delay_ms(a);
PORTB = 0XFF;
PORTD = 0X0F;
_delay_ms(a);
PORTB = 0XFF;
PORTD = 0X1F;
_delay_ms(a);
PORTB = 0XFF;
PORTD = 0X3F;
_delay_ms(a);
PORTB = 0XFF;
PORTD = 0X7F;
_delay_ms(a);
PORTB = 0XFF;
PORTD = 0XFF; //wszystkie schody swiecą
//sekwencja wygaszania od punktu A do B
_delay_ms(a);
PORTB = 0XFE;
PORTD = 0XFF;
_delay_ms(a);
PORTB = 0XFC;
PORTD = 0XFF;
_delay_ms(a);
PORTB = 0XF8;
PORTD = 0XFF;
_delay_ms(a);
PORTB = 0XF0;
PORTD = 0XFF;
_delay_ms(a);
PORTB = 0XE0;
PORTD = 0XFF;
_delay_ms(a);
PORTB = 0XC0;
PORTD = 0XFF;
_delay_ms(a);
PORTB = 0X80;
PORTD = 0XFF;
_delay_ms(a);
PORTB = 0X00;
PORTD = 0XFF;
_delay_ms(a);
PORTB = 0X00;
PORTD = 0XFE;
_delay_ms(a);
PORTB = 0X00;
PORTD = 0XFC;
_delay_ms(a);
PORTB = 0X00;
PORTD = 0XF8;
_delay_ms(a);
PORTB = 0X00;
PORTD = 0XF0;
_delay_ms(a);
PORTB = 0X00;
PORTD = 0XE0;
_delay_ms(a);
PORTB = 0X00;
PORTD = 0XC0;
_delay_ms(a);
PORTB = 0X00;
PORTD = 0X80;
_delay_ms(a);
PORTB = 0X00;
PORTD = 0X00;
//wszystkie wygaszone
//pojedyncze zapalanie tam i z powrotem
_delay_ms(b);
PORTB = 0X01;
PORTD = 0X00;
_delay_ms(b);
PORTB = 0X02;
PORTD = 0X00;
_delay_ms(b);
PORTB = 0X04;
PORTD = 0X00;
_delay_ms(b);
PORTB = 0X08;
PORTD = 0X00;
_delay_ms(b);
PORTB = 0X10;
PORTD = 0X00;
_delay_ms(b);
PORTB = 0X20;
PORTD = 0X00;
_delay_ms(b);
PORTB = 0X40;
PORTD = 0X00;
_delay_ms(b);
PORTB = 0X80;
PORTD = 0X00;
_delay_ms(b);
PORTB = 0X00;
PORTD = 0X01;
_delay_ms(b);
PORTB = 0X00;
PORTD = 0X02;
_delay_ms(b);
PORTB = 0X00;
PORTD = 0X04;
_delay_ms(b);
PORTB = 0X00;
PORTD = 0X08;
_delay_ms(b);
PORTB = 0X00;
PORTD = 0X10;
_delay_ms(b);
PORTB = 0X00;
PORTD = 0X20;
_delay_ms(b);
PORTB = 0X00;
PORTD = 0X40;
_delay_ms(b);
PORTB = 0X00;
PORTD = 0X80;
_delay_ms(b);
PORTB = 0X80;
PORTD = 0X00;
_delay_ms(b);
PORTB = 0X40;
PORTD = 0X00;
_delay_ms(b);
PORTB = 0X20;
PORTD = 0X00;
_delay_ms(b);
PORTB = 0X10;
PORTD = 0X00;
_delay_ms(b);
PORTB = 0X08;
PORTD = 0X00;
_delay_ms(b);
PORTB = 0X04;
PORTD = 0X00;
_delay_ms(b);
PORTB = 0X02;
PORTD = 0X00;
_delay_ms(b);
PORTB = 0X01;
PORTD = 0X00;
_delay_ms(b);
PORTB = 0X00;
PORTD = 0X80;
_delay_ms(b);
PORTB = 0X00;
PORTD = 0X40;
_delay_ms(b);
PORTB = 0X00;
PORTD = 0X20;
_delay_ms(b);
PORTB = 0X00;
PORTD = 0X10;
_delay_ms(b);
PORTB = 0X00;
PORTD = 0X08;
_delay_ms(b);
PORTB = 0X00;
PORTD = 0X04;
_delay_ms(b);
PORTB = 0X00;
PORTD = 0X02;
_delay_ms(b);
PORTB = 0X00;
PORTD = 0X00;
_delay_ms(b);
}
}
}[/syntax]

Drugi program ATTiny realizujący odliczanie czasowe:

[syntax=csharp]#include <avr/io.h>
#include <util/delay.h>

void mDelay( uint16_t ms);

int main(void)
{
//Port B jako wyjścia z wyjątkiem PB2, które jest wejściem
DDRB = 0X2B;
//Stan niski na wyjściach
PORTB = 0x00;

//Początek nieskończonej pętli
while(1)
{
//Jeżeli na pin PB2 podany zostanie stan wysoki
if(PINB & 0X04) {
mDelay(15000);
PORTB = 0X02; //stan wysoki na PB1
mDelay(1000); //opóżnienie 1000 * 1ms = 1000ms = 1s
PORTB = 0X00; //stan niski na PB1
}
}
}

void mDelay( uint16_t ms) {
while( ms-- )
{
_delay_ms(1);
if( !(PINB & 0x04) ) break; //jeśli PB2 w stanie niskim, przerwij wykonywanie pętli
}
}[/syntax]

Bardzo bym prosił o jakąkolwiek pomoc w jaki sposób "zlepić" te dwa programy w jedną całość.

Statystyki: Napisane przez kozak0211 — 12 sie 2019, o 13:23

]]>