Polecenia sterujące Craftsman 315 115790

Craftsman 315 115790 to uniwersalny sterownik Craftsman, który może być używany do sterowania wieloma rodzajami sprzętu. Sterownik ma wbudowaną bazę danych zawierającą wszystkie niezbędne informacje o urządzeniach, które może obsługiwać. Jest również wyposażony w funkcję inteligentnego sterowania, która pozwala mu dostosowywać ustawienia w zależności od warunków panujących w pomieszczeniu. Dodatkowo sterownik ma wiele przydatnych funkcji, takich jak automatyczne dostosowywanie się do warunków otoczenia, łatwa obsługa i konfigurowanie, a także możliwość łatwego wymiany części.

Ostatnia aktualizacja: Polecenia sterujące Craftsman 315 115790

vi

Autor	Bill Joy	Pierwsze wydanie	1976	Aktualna wersja stabilna	050325 (25 marca 2005) [±]	Język programowania	C	System operacyjny	Unix	Rodzaj	edytor tekstu	Licencja	BSD

vi – ekranowy, modalny edytor tekstu, używany w systemach Unix. Jego autorem jest Bill Joy. Nazwa pochodzi od angielskiego wyrazu visual.

Układ klawiatury ADM3A, dla której Bill Joy napisał program vi. Klawisz Esc jest łatwo dostępny obok Q.

Edytor vi w praktyce został wyparty przez klony, takie jak Vim, nvi lub elvis, które oferują bogatsze możliwości. Pozostaje jednym z narzędzi administratora ze względu na powszechność i jednolitość implementacji.

Użytkownik vi widzi na ekranie fragment treści pliku tekstowego, po którym może poruszać się (za pomocą kursorów), może dokonywać zmian tekstu i dopisywać nowy tekst. Edytor vi można uruchomić z argumentem będącym nazwą pliku. Jeżeli taki plik nie istnieje, to zostanie utworzony nowy.

Edytor vi w odróżnieniu od większości edytorów jest modalny – w każdej chwili znajduje się w jednym z dwu trybów pracy: trybie wstawiania lub trybie poleceń. Bezpośrednio po uruchomieniu vi znajduje się w trybie poleceń. Przejście do trybu wstawiania odbywać się może m. in. przez wydanie polecenia i (insert) lub a (append). Polecenia vi nie wymagają potwierdzenia klawiszem Enter, wykonywane są natychmiast.

Przejście z trybu wstawiania do trybu poleceń odbywa się przez naciśnięcie klawisza Esc.

W istocie vi jest edytorem ex działającym w trybie wizualnym, dlatego wszystkie polecenia edytora ex dostępne są także w vi. Polecenia ex wydawane w trybie poleceń poprzedzane są dwukropkiem : i wymagają potwierdzenia klawiszem Enter.

Polecenia[edytuj | edytuj kod]

Polecenia edytora vi składają się z kilku grup.

Polecenia edycyjne:

• a – wpisywanie tekstu za kursorem
• A – wpisywanie tekstu na końcu aktualnej linii
• i – wstawianie tekstu przed kursorem
• I – wstawianie tekstu na początku aktualnej linii
• o – utworzenie nowej linii poniżej aktualnej
• O – utworzenie nowej linii powyżej aktualnej
• R – zastępowanie tekstu
• s – zastąpienie znaku wskazanego przez kursor
• S – zastąpienie aktualnej linii
• c – zmiana zaznaczonego tekstu
• C – zmiana do końca linii

Polecenia zmieniające tekst:

• x – skasowanie znaku wskazywanego przez kursor
• X – skasowanie znaku przed kursorem
• d – skasowanie wskazanego tekstu
• dd – skasowanie aktualnej linii
• d<liczba>d – skasowanie kilku wierszy określonych liczbą, począwszy aktualnej linii
• D – skasowanie tekstu od aktualnej pozycji aż do końca linii
• y – skopiowanie wskazanego tekstu do bufora pomocniczego
• Y – skopiowanie linii tekstu do bufora pomocniczego
• p – wstawienie tekstu za kursorem
• P – wstawienie tekstu przed kursorem
• J – połączenie linii
• > – przesunięcie tekstu w prawo
• < – przesunięcie tekstu w lewo
• ! – przetworzenie tekstu przez polecenie systemowe i zastąpienie tego tekstu przez wyjście tego polecenia
• r – zastąpienie znaku wskazywanego przez kursor
• m – zaznaczenie linii tekstu
• u – anulowanie ostatniej zmiany (ponowne wciśnięcie powoduje ponowne zastosowanie ostatniej zmiany)
• . – powtórzenie polecenia

Polecenia sterujące kursorem:

• 0 – przeniesienie kursora na początek linii
• ^ – przeniesienie kursora na początek linii
• $ – przeniesienie kursora na koniec linii
• h – przeniesienie kursora w lewo
• j – przeniesienie kursora w dół
• k – przeniesienie kursora w górę
• l – przeniesienie kursora w prawo
• ^H – skasowanie znaku przed kursorem (klawisz backspace)
• f – przeniesienie do przodu do podanego znaku
• F – przeniesienie do tyłu do podanego znaku
• t – przeniesienie do przodu przed wskazany znak
• T – przeniesienie do tyłu przed wskazany znak
• ; – powtórzenie ostatniego polecenia f, F, t, T
• , – odwrócenie działania ostatniego polecenia f, F, t, T
• | – ustawienie kursora w podanej kolumnie
• % – odnalezienie pary dla wskazanego nawiasu
• B – ustawienie kursora na początku poprzedniego słowa (słowo = ciąg znaków bez znaków białych)
• W – ustawienie kursora na początku następnego słowa (słowo = ciąg znaków bez znaków białych)
• H – przeniesienie kursora na górę ekranu
• L – przeniesienie kursora na dół ekranu
• :<liczba> – przeniesienie kursora do wiersza wskazanego liczbą
• spacja – przeniesienie kursora w prawo

Polecenia sterujące ekranem:

• ^F – przesunięcie okna ekranowego o jeden ekran do przodu
• ^B – przesunięcie okna ekranowego o jeden ekran do tyłu
• G – przesunięcie okna ekranowego do podanej linii
• / – wyszukanie podanego wzorca w przód (po dojściu na koniec pliku kontynuowanie szukania od początku)
• ? – wyszukanie podanego wzorca w tył (po dojściu na początek pliku kontynuowanie szukania od końca)
• ^L – wyczyszczenie i przerysowanie ekranu
• ^R – przerysowanie ekranu

Wybrane polecenia ex:

• :q – wyjście z edytora pod warunkiem braku zmian od ostatniego zapisu
• :q! – wyjście z edytora bez zapisania pliku
• :w – zapisanie pliku
• :w nazwa – zapisanie pliku pod nową nazwą
• :w! – zapisanie pliku (z wymuszonym zapisaniem plików tylko do odczytu)
• :wq – wyjście z edytora z zapisaniem pliku
• :x – wyjście z edytora z zapisaniem pliku (bez zapisania przy braku zmian)
• :x! – wyjście z edytora z zapisaniem pliku (bez zapisania przy braku zmian, z wymuszonym zapisaniem plików tylko do odczytu)
• ZZ – wyjście z edytora z zapisaniem pliku
• :e nazwa – otworzenie pliku do edycji
• :help – wyświetlenie pomocy
• :xq - wyjście z edytora bez zapisania pliku (alternatywa dla :q! )

Przykładowe zestawy poleceń

• :%s /<ciąg1> /<ciąg2> - Wyszukuje ciąg znaków pasujący do wzorca ciąg1 i zamienia go ciągiem2
• :%sg /<ciąg1> /<ciąg2> - Wyszukuje ciąg znaków pasujący do wzorca ciąg1 i zamienia go ciągiem2 w całym dokumencie
• :%s /^V^M / - Usuwa znaki ^M (^V jest znakiem nieinterpretowania znaku ^M)

vi i jego pochodne posiadają wystarczającą liczbę zwolenników do powstania tak zwanej wojny edytorowej między nimi a zwolennikami Emacsa.

Zalety vi[edytuj | edytuj kod]

Edytor vi pomimo pozornego anachronizmu nadal jest wykorzystywany przez administratorów i programistów. Jego największe zalety to:

• z racji standaryzacji w ramach POSIX edytor jest dostępny na każdym systemie uniksowym bez instalacji,
• możliwość pracy w bardzo ubogim środowisku terminalowym – bez grafiki i przy ograniczonym zestawie znaków,
• możliwość pełnoekranowej edycji plików nawet przy bardzo wolnym łączu – przez sieć dla każdej edycji przesyłane jest tylko tyle znaków, ile zostało wpisane, a odświeżany jest tylko niewielki fragment tekstu, którego dotyczy edycja.
• w wielu powłokach po wydaniu polecenia set -o vi możliwe jest korzystanie z wiersza poleceń jak z edytora vi. Wciskając klawisz Esc przechodzi się do trybu poleceń, w którym możliwe jest sterowanie kursorem i wyszukiwanie w historii.

Zobacz też[edytuj | edytuj kod]

• ed, ex

ANG-3001 – terminal produkowany w Polsce przez gdański Unimor w latach osiemdziesiątych, przeznaczony do współpracy z różnymi systemami komputerowymi, w tym między innymi stosowany wraz z komputerem Bosman 8. Był to terminal graficzny, bowiem umożliwiał pracę nie tylko w trybie tekstowym 25 wierszy (24 wiersze robocze + 1 wiersz komunikatów) na 80 znaków w wierszu, ale także w trybie graficznym 512x256 punktów (monochromatycznym). Terminal posiadał wbudowane wszystkie funkcje terminala alfanumerycznego AN-2001 oraz dodatkowe funkcje graficzne.

Elementy podstawowe[edytuj | edytuj kod]

Terminal składał się z dwóch zasadniczych elementów:

• monitora Neptun M159 (z dodatkowym zasilaczem),
• klawiatury T6162, w obudowie której umieszczony był mikrokomputer sterujący pracą terminala i pamięć obrazu.

Klawiatura[edytuj | edytuj kod]

Klawiatura T6162 była klawiaturą hallotronową, o układzie typu QWERTY o 78 klawiszach podzielonych na 3 odrębne sekcje:

• klawiszy funkcyjnych – 4 klawisze,
• klawiszy numerycznych – 17 klawiszy,
• blok podstawowy – 59 klawiszy, w tym blok alfanumeryczny – 49 klawiszy.

W terminalu stosowano kodowanie znaków w zakresie kodów od 0 do 127 według ISO-7. Dostępne były wszystkie polskie litery diakrytyczne, a także znaki alfabetu greckiego.

Monitor[edytuj | edytuj kod]

Monitor M159 był monitorem monochromatycznym. Ekran miał 12 cali (30 cm). Pracował w jednym z dwóch trybów:

• tekstowym, w którym dostępne były 24 linie po 80 znaków oraz dodatkowy 25 (górny) wiersz komunikatów;
• graficznym, 512 × 256 punktów.

Terminal dawał możliwość definiowana okien zapisywanych na stosie, w których zasady realizacji komend (edycji) były identyczne jak dla całego ekranu.

Tryby pracy[edytuj | edytuj kod]

Terminal dawał możliwość pracy w dwóch trybach (przełączanie trybu pracy umożliwiał jeden z klawiszy funkcyjnych o nazwie LOCAL):

• LOCAL – kod znaku z klawiatury umieszczany był w pamięci obrazu każdy więc znak wygenerowany na klawiaturze jest wyświetlany na monitorze; urządzenie pracuje w tym trybie jako samodzielna jednostka, można np. testować poprawność pracy terminala i jego wszystkie funkcje bez udziału systemu komputerowego,
• DUPLEX – kod znaku z klawiatury przesyłany był do sterownika interfejsu (systemu komputerowego), kod może (ale nie musi) zostać odesłany do terminala i zostać wyświetlony na monitorze, bowiem w tym trybie pracy wyświetlany obraz przesyłany jest z systemu komputerowego.

Polecenia sterujące[edytuj | edytuj kod]

W terminal wbudowano polecenia sterujące. Ich wydawanie operator komputera mógł realizować za pomocą klawisza Esc, po którym należało wprowadzić kolejne znaki. Polecenia te obejmowały następujące operacje:

• polecenia dla trybu tekstowego:
  • operacje na oknach
  • sterowanie kursorem
  • przesuwanie obrazu
  • kasowanie treści
  • operacje na kursorze
  • wybór generatora znaków
  • zmiana alfabetu
  • inwersja znaków
  • pytanie o rodzaj terminala
  • pisanie znaków w linii komunikatów
  • sygnał dźwiękowy
  • pisanie dużych znaków
  • definiowanie dodatkowych poleceń
  • testy
• polecenia graficzne:
  • ustawienie sposobu realizacji poleceń graficznych
  • rysowanie punktów, linii, prostokątów, znaków
  • przełączanie, powiększanie, negowanie obrazu
  • pisanie i czytanie: pamięć obrazu – system komputerowy
  • kasowanie linii, przesuwanie obrazu
• przełączanie trybów.

Mikrokomputer sterujący[edytuj | edytuj kod]

Mikrokomputer sterujący wykonywany był na jednej płytce (obwodzie drukowanym) montowanej w klawiaturze. Klawiatura i mikrokomputer zasilane były z zasilacza umieszczonego w monitorze Neptun M159. Tu również znajdowała się pamięć obrazu (a w zasadzie dwie pamięci dla dwóch obrazów, co umożliwiało przełączanie między pamięciami i np. pracę tekstową na jednej pamięci i graficzną na drugiej). Oparto go o procesor Z80B i wyposażono w 64 kB pamięci RAM oraz 16 kB pamięci EPROM, w której zapisany był monitor sterujący pracą terminala.

Terminal komunikował się z systemem komputerowym za pomocą interfejsu szeregowego (standard sygnałów CCITT V. 24). Istniała możliwość zmiany generatora znaków. Dodatkowo terminal mógł być wyposażony w złącze drukarki standardu Centronics (gniazdo 25 stykowe).

Bibliografia[edytuj | edytuj kod]

• Terminal ANG-3001, Instrukcja obsługi. Gdańskie Zakłady Elektroniczne Unitra Unimor. GZE 5114/87. (pol. ).
• Mikrokomputer Bosman 8, Instrukcja obsługi. GZE 5112/87. btitle=Mikrokomputer+Bosman+8%2C+Instrukcja+obs%C5%82ugi&rft.
• Unimor Bosman 8. www. pl – Dziennik miłośnika polskich komputerów. [dostęp 2011-10-24]. (pol.

Uwaga! Informacje na tej stronie mają ponad 6 lat. Nadal je udostępniam, ale prawdopodobnie nie odzwierciedlają one mojej aktualnej wiedzy ani przekonań.

• 4. Instrukcje sterujące
  • 4. 1. Instrukcja warunkowa if
  • 4. 2. Instrukcja wyboru switch
    • 4. 3. Pętle
      • • • • 4. 4. Polecenia sterujące pętlami
            • • 4. 5. PROJEKT - reklama

                Najdłuższą i najtrudniejszą część kursu mamy już za sobą.Znamy wszystkie rodzaje danych, ale nadal nie potrafimy tworzyćprawdziwych skryptów. Nie powiedzieliśmy bowiem jeszcze o tym, co w każdym języku programowaniamusi być i jest bardzo istotne. Mowa o instrukcjach sterujących przebiegiem sterowaniakodu.

                4. Instrukcja warunkowa if

                Instrukcja warunkowa pozwala wykonać jakiś fragment kodu pod jakimś warunkiem.

                Składnia if:

                if {<warunek>} {<kod>} elseif {<warunek>} {<kod>} else {<kod>}

                Bloków elseif może być tyle, ile chcesz.Może też nie być wcale i wtedy zostanie samo if i else.Może też zostać samo if.

                Instrukcja warunkowa wykona fragment kodu tylko jeśli podany warunek zostanie spełniony.W przeciwnym wypadku wykona kod zawarty w else.Jako warunek można podać dowolne wyrażenie zwracające ostatecznie wartość logicznąwg takiej samej składni, jak w poleceniu expr.

                Ważne jest by pamiętać o pisaniu nawiasów klamrowych dokładnie tak jak w przykładzie powyżej.Jeśli spróbujesz przenieść je do osobnych wierszy, powstanie błąd.

                Poniższy przykład sprawdza zakres podanej liczby:

                Przykład z if:

                proc SetLiczba {a_iLiczba} {variable m_iLiczbaif {$a_iLiczba < 0} {set m_iLiczba 0} elseif {$a_iLiczba > 100} {set m_iLiczba 100} else {set m_iLiczba $a_iLiczba}}

                4. Instrukcja wyboru switch

                Jeśli chcesz podjąć jedną z wielu akcji w zależności od jakiejś wartości, lepszymwyborem będzie użycie instrukcji wyboru:)

                Instrukcja switch wybiera jedną z dostępnych możliwości dopasowującpodaną wartość do wartości zawartych w jej wnętrzu i w zależności od tego wykonujepodany kod. Jeśli podana wartość nie pasuje do żadnej sprawdzanej, wykonany zostaniekod podany jako default, jeśli taki istnieje (nie trzeba go umieszczać).

                Składnia switch:

                switch <wartość> {<wartość> {<kod>}default {<kod>}}

                Przykład ze switch:

                switch $iLiczba {0 {Debug "Wartosc minimalna"}100 {Debug "Wartosc maksymalna"}Debug "Inna wartosc"}}

                4. Pętle

                Pętla pozwala wykonać zawarty w niej fragment kodu wiele razy, np.określoną liczbę razy, dla każdego elementu listy lub najczęściej tyle razy,ile potrzeba by podany warunek sprawdzany przed lub po każdej iteracji pętlizwrócił określoną wartość logiczną.Istnieje kilka rodzajów pętli:

                4. Pętla while

                Składnia pętli while:

                while {<warunek>} {
                W każdej iteracji najpierw sprawdzany jest warunek, a następnie wykonywany kod,o ile warunek jest prawdziwy (zwraca 1).Ponieważ warunek sprawdzany jest na początku, istnieje możliwość że będzie onfałszywy już za pierwszym razem i kod zawarty w pętli nie wykona się ani razu.
                Przykład pętli while:
                set i 0while {$i < 10} {Debug $iincr i}
                Powyższy kod wypisuje kolejne liczby od 0 do 9. 
                4. Pętla for
                Składnia pętli for:
                for {<instrukcja-inicjalizacji>} {<warunek>} {<instrukcja-iteracji>} {
                <instrukcja-inicjalizacji>
                To instrukcja, która wykonuje się raz, podczas uruchamiania pętli.Działa tak samo, jak gdybyś postawił ją tuż przed pętlą jako osobną instrukcję.
                <warunek>
                To warunek sprawdzany przed każdą iteracją pętli.Kod wykonywany jest tylko, jeśli jest on spełniony.
                <instrukcja-iteracji>
                To instrukcja, która wykonuje się po każdej iteracji pętli.
                Najczęściej pętlę tą wykorzystuje się w podany niżej sposób,z użyciem tzw. zmiennej sterującej. Jej wartość jest inicjalizowanaw instrukcji inicjalizującej, sprawdzana w warunku, zmieniana(np. inkrementowana) w instrukcji iteracji i wykorzystywana w kodzie.
                Przykład pętli for:
                for {set i 0} {$i < 10} {incr i} {Debug $i}
                Nietrudno się domyślić, że kod ten robi dokładnie to samo, co przykład z poprzedniej pętli.
                4. Pętla foreach
                Składnia pętli foreach:
                foreach <zmienna> <lista> {
                Pętla ta pozwala iterować po kolejnych elementach listy.Dla każdego elementu podanej listy wykonywany jest podany kod,a wartość tego elementu na czas jego wykonania przypisywania jestpodanej zmiennej.
                Przykład pętli foreach:
                set lLista1 {{ "Programowanie" "ciekawe"}{ "TCL" "prosty"}}foreach lElement $lLista1 {Debug "[lindex $lElement 0] jest [lindex $lElement 1]"}
                Pętla foreach doskonale nadaje się także, oprócz list, do iteracji poelementach tablicy. Wystarczy otrzymać listę kluczy tablicy poleceniemarray names.
                4. Polecenia sterujące pętlami
                break
                To polecenie przerywa wykonywanie pętli i powoduje natychmiastowe wyjście z niej.
                continue
                To polecenie powoduje natychmiastowe rozpoczęcie nowej iteracji pętli.
                4. Instrukcja obsługi błędów catch
                Jak sama nazwa wskazuje, instrukcja ta służy do łapania.Zapewne podczas programowania w TCL już nieraz spotkałeś się z błędami.Niezłapany błąd powoduje przerwanie wykonywania kodu lub, jeśli to był kodwykonywany podczas ładowania bota, całkowity jego wysyp.Teraz nauczymy się, jak błędy można łapać.
                Składnia catch:
                catch {
                Podany kod jest wykonywany, ale wystąpienie błędu nie powoduje przerwania dalszegowykonywania skryptu.Instrukcja ta zwraca 0 jeśli podczas wykonywania kodu nie wystąpił błąd lub kod błędu,jeśli błąd wystąpił.
                Wyłapywane są wyłącznie błędy podczas wykonywania.Instrukcja ta nic nie pomoże na błędy składniowe języka TCL uniemożliwiające kompilacjęjego kodu.
                4. PROJEKT - reklama
                Ta część była krótka, więc za to projekt będzie długi:)Przedstawię skrypt do okresowego wyświetlania reklam na wybranym kanale.Analizę tego kodu pozostawiam tobie jako zadanie.
                reklama. tcl:
                ############################################################################ Autor: Regedit# Data: 2003-08-15# Opis: Skrypt do wyświetlania przerwy na reklamę############################################################################ CEL# Skrypt ma co jakiś czas wyświetlać na jednym, ustalonym kanale wybraną# wiadomość reklamową. Wyświeli ją tylko jeśli nikt nic na kanale nie mówi# przez conajmniej 10 minut, jednak nie częściej niż raz na godzinę.# Baza danych# Enkapsuluje funkcjonalność bazy reklamnamespace eval db {# --- STAŁE ---# Ścieżka do pliku z baząset sFileName "database/reklama. db"# --- ZMIENNE ---# Czy baza została zmodyfikowana od ostatniego otwarciaset bModified 0# Tablica z zawartością bazy# aData# --- PROCEDURY ---# Otwiera bazęproc Begin {} {variable sFileNamevariable bModifiedvariable aData# Jeśli plik istniejeif { [file exists $sFileName]} {# Otwarcie plikuset hFile [open $sFileName r]# Odczytanie danych z pliku do tablicywhile {! [eof $hFile]} {set sKey [gets $hFile]set sValue [gets $hFile]if { ($sKey! = "") && ($sValue! = "")} {set aData($sKey) $sValue}}# Zamknięcie plikuclose $hFile}# Tyle co wczytałem - nie zmodyfikowanyset bModified 0}# Zamyka bazę i jeśli trzeba, zapisuje zmianyproc End {} {# Jeśli dane zostały zmodyfikowaneif {$db::bModified} {set hFile [open $sFileName w]# Zapisanie danych do plikuif { [ array exists aData]} {foreach {sKey sValue} [array get aData] {puts $hFile $sKeyputs $hFile $sValue}}# Wyczyszczenie tablicyif { [array exists aData]} {array unset aData}}# Zapisuje rekordproc SetRec { a_sKey a_sValue} {set aData($a_sKey) $a_sValueset bModified 1}# Usuwa rekordproc DelRec { a_sKey} {unset aData($a_sKey)# Odczytuje rekordproc GetRec { a_sKey} {return $aData($a_sKey)}# Zwraca listę kluczyproc GetKeys {} {return [array names aData]}# Zwraca liczbę rekordówproc GetCount {} {return [array size aData]}}# Bindy# Binduje dowolny tekst wypowiedziany na kanalebind pubm - * OnPubm# Przed rehash - by usunąć timerbind evnt - prerehash OnPreRehash# --- STEROWANIE ---# Polecenie głównebind msg n "reklama" OnMain# Polecenie zapisania (dodanie lub modyfikacja) rekordubind msg n "reklama_set" OnSet# Polecenie odczytania rekordubind msg n "reklama_get" OnGet# Polecenie usunięcia rekordubind msg n "reklama_del" OnDel# Polecenie wylistowania kluczy rekordówbind msg n "reklama_list" OnList# Stałe# Nazwa kanału, na którym ma pracować skrypt wyświetlając reklamyset Channel "#lamerlandia"# Czas krótszy (oczekiwanie na ciszę na kanale)set Time1 10# Czas dłuższy (przerwa między wyświetleniami reklamy)set Time2 60# Zmienne# 1 lub 0 zależnie, czy ktoś coś powiedział na kanale od ostatniego timeraset Said 0# ID timeraset TimerID ""# Procedury# Wysyła priv do autora w celu debugowaniaproc Debug {aText} {putserv "PRIVMSG Nick:(DEBUG) $aText"}# Wysyła priv w odpowiedziproc Response { a_sNick a_sText} {puthelp "PRIVMSG $a_sNick:$a_sText"}# Wysyła linijkę reklamyproc Reklamuj { a_sText} {global Channelputserv "PRIVMSG $Channel:$a_sText"}# Wyświetla reklamęproc Go {} {db::BeginReklamuj "#################### R E K L A M A ####################"foreach {sRow} [split [db::GetRec [lindex [db::GetKeys] [rand [db::GetCount]]]] "|"] {Reklamuj $sRow}Reklamuj "#######################################################"db::End}# Ustawia timer na podany w parametrze czasproc SetTimer {aCzas} {global TimerIDset TimerID [timer $aCzas "OnTimer"]}# Usuwa timerproc KillTimer {} {if {$TimerID! = ""} {killtimer $TimerID}}# Procedura obsługi zdarzenia timeraproc OnTimer {} {global Said Time1 Time2# jeśli ktoś coś powiedziałif {$Said == 1} {SetTimer $Time1# jeśli nikt nic nie powiedział} else {GoSetTimer $Time2}set Said 0}# Procedura reakcji na zdarzenie powiedzenia czegokolwiek na kanaleproc OnPubm {aNick aHost aHandle aChannel aText} {global Channel Saidif {$aChannel! = $Channel} { return 0}set Said 1return 0}# reakcja na zdarzenie przed rehashemproc OnPreRehash {type} {KillTimer}proc OnMain {a_sNick a_sHost a_sHandle a_sText} {Response $a_sNick "*REKLAMA* Dostepne polecenia: reklama | reklama_set <key> <value>\| reklama_get <key> | reklama_del <key> | reklama_list"}proc OnSet {a_sNick a_sHost a_sHandle a_sText} {set lList [split $a_sText]set sKey [lindex $lList 0]set sValue [join [lrange $lList 1 end]]db::SetRec $sKey $sValuedb::EndResponse $a_sNick "Reklama \"$sKey\": \"$sValue\" dodana"}proc OnGet {a_sNick a_sHost a_sHandle a_sText} {Response $a_sNick [db::GetRec $a_sText]proc OnDel {a_sNick a_sHost a_sHandle a_sText} {db::DelRec $a_sTextResponse $a_sNick "Reklama \"$a_sText\" usunieta"}proc OnList {a_sNick a_sHost a_sHandle a_sText} {set bFirst 1set sResult ""foreach {sKey} [lsort -dictionary [db::GetKeys]] {if {$bFirst} {append sResult "$sKey"set bFirst 0} else {append sResult " $sKey"}}Response $a_sNick $sResult# Kod# Zainicjalizowanie timeraSetTimer $Time2# Zalogowanie załadowania skryptuputlog "reklama... loaded"
                Adam Sawicki