Na forum Stalker.pl zamieściłem tutorial traktujący o tym, jak dołączyć nowo utworzony przez nas (lub i nie przez nas...) poziom (level) do grafu gry (game graph), wraz z utworzeniem odpowiednich przejść pomiędzy poziomami (level changers) dla gry S.T.A.L.K.E.R. - Cień Czarnobyla. Poradnik zakłada podstawową znajomość narzędzia Level Editor oraz pakietu X-Ray SDK.

Artykuł można znaleźć tutaj, natomiast poniżej można obejrzeć krótki filmik obrazujący efekt przejścia przez poradnik.

Miłego moddowania!

Microsoft w jądrze Windows 7 wprowadził kilka bardzo fajnych nowości, "zapomniał" jednak o pozostawieniu jakiejś furtki końcowym użytkownikom, jeśli chodzi o zasady bezpieczeństwa. Mianowicie problemem stały się sterowniki do urządzeń, które nie są podpisane żadnym zaufanym certyfikatem. Można co prawda po jednej korekcie w opcjach systemu takowe sterowniki zainstalować, jednak urządzenie nadal działać nie będzie.

W związku z taką sytuacją, jedynym wyjściem do tej pory było wchodzenie w tryb awaryjny systemu. Nie jest to jednak ani wygodne, ani bezpieczne. Dlatego też, poniżej opiszę sposób, jak krok po kroku, pozbyć się tej uciążliwości.

Zaczniemy od włączenia możliwości instalacji niepodpisanych sterowników. Z poziomu Panelu Sterowania uruchamiamy Edytor lokalnych zasad grupy i w lewym panelu nawigujemy do pozycji Konfiguracja użytkownika -> Szablony administracyjne -> System -> Instalacja sterowników. Otwieramy pozycję o nazwie Podpisywanie kodu dla sterowników urządzeń:

Zmieniamy ustawienie wg powyższego screena i zatwierdzamy. Następnie, pozbywamy się kolejnego ograniczenia. Uruchamiamy Ustawienia kontroli konta użytkownika i wyłączamy cały podsystem kontroli:

W tym momencie sterowniki można już instalować, ale... nie można ich nadal używać - co stawia pod znakiem zapytania inteligencję projektantów systemu... po co zezwalać na instalację, skoro to i tak nic nie daje? Restartujemy komputer i pobieramy program Driver Signature Enforcement Overrider, który pozwoli nam na uruchomienie naszych sterowników.

Wybieramy opcję Enable test mode, następnie Exit i ponownie restartujemy system. Po ponownym uruchomieniu, nasz system jest gotowy na przyjęcie wielu nowych urządzeń Jako dowód poniżej zrzut ekranowy z Menadżera urządzeń z zazanczonymi urządzeniami, które zostały zainstalowane wyżej opisaną metodą. Powodzenia!

Już grubo od ponad pół roku z serwisu BrotherSoft można pobrać moją aplikację zwaną ufp, która właśnie uzyskała status Editor's Pick. Cóż to jest?

Jest to aplikacja stworzona głównie z myślą o wysterowaniu paneli LEDowych, używanych powszechnie w reklamie (tzw. LED walls). Można ją jednak wykorzystać również do odtwarzania prezentacji w ogólnym pojęciu (np. projektor podpięty do laptopa). Pozwala ona zdefiniować obszar na ekranie, który będzie przeznaczony do odtwarzania, a następnie umożliwia ułożenie playlisty, która cyklicznie będzie odtwarzana. Obsługiwane formaty plików to przede wszystkim animacje Flash w formacie SWF, a także obrazy JPEG i PNG. Ważną cechą, wyróżniającą ten program wśród innych, jest brak tzw. sandboksa, co umożliwia uruchamianie animacji flashowych korzystających z internetu (np. w celu pobrania przez sieć danych do wyświetlenia).

Aplikację pisałem dla siebie i jej używałem z powodzeniem na wielkich imprezach - i się sprawdza
Zapraszam do pobierania i testowania aplikacji.

Since last fall on the BrotherSoft you can find my apllication, called ufp, which just got the Editor's Pick status. What's that?

It's the application designed for driving LED walls, commonly used in advertisement market - but you can also use it for general purposes, too - let's say with the projector attached to a notebook. First, you can define the area on the screen, which will be used for playing the files, and then you can plan your playlist. In the playlist you can use Flash animations (in SWF format) and PNG or JPEG images. What is the power of this little application is the Flash player isn't closed in the sandbox. What that means? It means you can play animations which are using the internet (ie. for downloading some data to be displayed).

I wrote this application for myself and I was using it with the success on really big events
Just go, download and test it.

Tworzysz właśnie aplikację w C++ pod linuksa lub Windows, której zadaniem są m.in. długie obliczenia? Myślałeś o zrównolegleniu tych obliczeń?
Jeśli tak - Intel udostępnia swój zestaw Intel® Concurrent Collections for C++. Cóż to takiego?

Concurrent Collections for C++ to zestaw kolekcji ("steps" dla obliczeń, "tags" dla kontroli oraz "items" dla danych), które umożliwiają przejrzystą implementację algorytmów równoległych. Zadania przedstawia się w formie grafu w specjalnie przygotowanej do tego celu notacji. Co więcej - Intel udostępnił również specjalne narzędzie wizualne do tworzenia owych grafów - GraphBuilder. Biblioteka łatwo integruje się z Microsoft Visual Studio.
Autorką technologii jest Kath Knobe, która wiele lat spędziła przy programowaniu superkomputerów, obecnie jest zatrudniona w Intelu.

Dostępne jest również forum poświęcone tej technologii.

Przy okazji tematu, polecam gorąco odwiedzenie portalu Parallel Commuinity, również prowadzonego przez Intel.

W pokoju córeczki, gdy idzie spać, zostawiamy małą lampeczkę włączoną. Potem, gdy nam się o niej przypomni, należy ją wyłączyć. Owo "gdy nam się o niej przypomni" trwa od godziny do 6 godzin Problem nie jest w poborze prądu, którego ta lampeczka pożera naprawdę niewiele, ale w tym, że jeśli się przebudzi w czasie, gdy lampka wciąż będzie się świecić, to albo się rozbudza, albo zabrania jej gasić - na kolejny okres czasu. Gdy się przebudzi przy zgaszonej już lampce - nie ma problemu. Dlatego też postanowiłem zbudować małego pomocnika w słusznej sprawie: timer dla urządzeń zasilanych z sieci 230V.

Schemat elektryczny tego urządzenia jest zwyczajnie banalny - ot, standardowe połączenie multipleksowanych dwóch cyfr 7-segmentowego wyświetlacza LED do mikrokontrolera PIC16F628A. Jako interfejs ustawiania zadanego czasu, można było zastosować dwa przyciski, ale ja u siebie wstawiłem enkoder obrotowy, który w obsłudze końcowej jest nieporównywalnie przyjemniejszy od przycisków - zwłaszcza, gdy przyjdzie nam ustawić czas rzędu np. 90 minut Zastosowanie enkodera pociąga za sobą zmiany w programie, gdyż działa on tak, że za pomocą dwu-bitowego kodu Graya odczytujemy stan urządzenia - a stany mogą być trzy: w lewo, w prawo i nieokreślony. Dlatego też oprogramowanie wewnętrzne mikrokontrolera nie będzie niestety pasować do zwykłych przycisków.

Modułem wykonawczym może być dowolna realizacja... może to być przekaźnik z cewką 5V, może być z własnym zasilaniem (np. 12V), może też to być zestaw optotriak-triak. Tę ostatnią opcję wybrałem dla swojej realizacji, jako, że z powodu swojego charakteru pasuje tutaj najbardziej do projektu. Poniżej możecie zobaczyć schematy pokazujące, jak zrealizować takie moduły wykonawcze.

Wsad do mikrokontrolera można pobrać tutaj. W razie jakichkolwiek problemów, czy to ze schematem, czy z oprogramowaniem - pytać Jeżeli macie jakieś pomysły na usprawnienie urządzonka - pisać.

Miłego odliczania czasu!

Pracowałem ostatnimi dniami nad małym kontrolerkiem, sterowanym przez RS232. Obsługa niektórych poleceń, wydawanych do niego, trwała nawet po kilka milisekund i... okazało się, że użyty przeze mnie 16F628A ma bufor wejściowy USARTa rozmiaru... 2 bajtów. Tak, to nie pomyłka

Dlatego postanowiłem napisać obsługę cyklicznego bufora wejściowego - o rozmiarze wg uznania Poniżej przedstawiam wam, jak coś takiego zrealizować.


Na początku, zmienne globalne:

#define RX_BUFOR_MAX        32
unsigned char buforRX[RX_BUFOR_MAX];
unsigned char *buforRX_head, *buforRX_end, *RXreadstart, RXbajt;

i podczas inicjalizacji programu:

    // ustawiamy bufor odbioru danych z UARTa
    buforRX_head = buforRX;
    buforRX_end = buforRX + RX_BUFOR_MAX;
    RXreadstart = buforRX;

Tyle przygotowań.

Proces odbioru danych i składowanie ich w cyklicznym buforze zrealizujemy w przerwaniu. Najpierw odpalamy przerwanie:

   STATUS.RP0 = 1;
   PIE1.RCIE = 1; // przerwanie odbioru danych z UARTa
   STATUS.RP0 = 0;
   PIR1 = 0;


   INTCON.GIE = 1;
   INTCON.PEIE = 1;

I definiujemy obsługę:

void    interrupt(void)
{
  // przyszedł znak z UARTa
  if (PIR1.RCIF)
  {
      // cykliczny bufor z użyciem "indirect addressing"
      asm {
          movf RCREG,W
          movwf _RXbajt
          movf _buforRX_head, W
          movwf FSR
          movf _RXbajt, W
          movwf INDF
          incf _buforRX_head, f
      }


      if (buforRX_head == buforRX_end) // koniec buforu,
          buforRX_head = buforRX;         // zawijamy ogon.
         

      PIR1.RCIF = 0; // koniec przerwania
  }
}

Pozostało nam napisanie funkcji korzystających z owego bufora. Wpierw funkcja badająca, czy w buforze czeka na nas jakiś nieprzetworzony znak:

// czy w cyklicznym buforze czekają dane do odczytania?
unsigned char BUFRS_Data_Ready()
{
    if (RXreadstart == buforRX_head)
        return 0;
    else
        return 1;
}

No i funkcja odczytująca kolejny znak:

// odczyt znaku z cyklicznego buforu
unsigned char BUFRS_Read()
{
    unsigned char bajt;
    asm {
        movf _RXreadstart, W
        movwf FSR
        movf INDF, W
        movwf BUFRS_Read_bajt_L0
        incf _RXreadstart, f
    }


    if (RXreadstart == buforRX_end)
        RXreadstart = buforRX;


    return bajt;
}

Na koniec przedstawię jeszcze moją małą funkcję odczytującą znak z określonym timeoutem operacji:

void BUFRS_Read_Timeout(unsigned char *bajt, unsigned char timeout)
{
    unsigned char tout, read;
    tout = 0;
    read = 1;
    *bajt = 0;
    while ((read == 1) && (tout < timeout))
    {
        if (BUFRS_Data_Ready() > 0)
        {
            *bajt = BUFRS_Read();
            read = 0;
        }
        else
            tout++;
    }
}

To tyle. U mnie - jak już pisałem, obsługa niektórych znaków zajmuje kilka milisekund, niektórych kilka mikrosekund - całość działa poprawnie przy 19200 (kwarc 20MHz). Oczywiście, powyższe działa tylko na mikrokontrolerach wyposażonych w sprzętowy moduł USART.

Powodzenia.

Zabawiałem się w ostatnich dniach wyświetlaczem LCD z poczciwej Nokii 3310. LCD nie jest rewelacyjny, ale ma te swoje 84x48 pikseli monochromatycznego obrazu. W trybie tekstowym, z małą czcionką, wystarcza to na 6 rzędów po 14 znaków.



Szukając w sieci biblioteki do jego obsługi, przejrzałem zyliony projektów typu "LCD-on-LPT" i nieco mniej, bo już tylko miliony projektów na wszelkie AVRki. PICe jakoś słabo były reprezentowane, a już mikroC najsłabiej. Dlatego skompilowałem z wszystkich dostępnych mi materiałów działającą bibliotekę. Z powodzeniem uruchomiłem ją na 2kB procesorze 16F628A (uwaga: LCD pracuje pod napięciem 3.3V!!)

Na chwilę obecną, biblioteka pozwala na wyświetlanie napisów w dwóch różnych rozmiarach - przy użyciu tylko jednego zdefiniowanego kroju pisma - skalowanie następuje w locie, podczas wyświetlania. W planach dodanie grafiki.

Biblioteka dostępna jest jako LGPL, podczas jej opracowywania, jak już wspominałem, wykorzystywałem różne źródła (no i własną pracę). Największymi dawcami idei i pomysłów byli Louis Frigon oraz Lieven Hollevoet.

Załączam również przykładowy projekt, wykorzystujący ów LCD i bibliotekę - taki mały zegarko-termometr Dzięki niemu można dowiedzieć się, jak podłączyć wyświetlacz i jak skorzystać z biblioteki. Zwracam tylko uwagę na konieczność ustawienia swoich pinów LCD w pliku N3310LCD.h.





Bibliotekę oraz przykładowy projekt znaleźć można na forum elektrody. A następny LCD w kolejce do rozpracowania jest przyjemny LCD kolorowy, o wymiarach 128x128 pikseli - dostępny na allegro za ok. 20zł

Metro 2033.

Co to jest? To po pierwsze książka autorstwa Dmitrija Glukhovsky'ego. Książka napisana rewelacyjnie, pochłaniająca czytelnika bez granic. Powiem o niej tylko tyle, że jej 600 stron(!) połknąłem w niecałą dobę, co powinno stanowić wystarczającą rekomendację do sięgnięcia po nią. A po drugie, to gra typu FPS (czyli strzelanka), oparta o tę książkę. Pieczę nad stroną fabularną gry trzymał autor książki, natomiast wykonaniem zajęło się studio 4A Games (wydawca to THQ). Co to za nieznane studio? Okazuje się, że w skład drużyny wchodzą ludzie, którzy pracowali nad pierwszą wersją kultowej gry S.T.A.L.K.E.R., co nie powinno jednak prowadzić do zbyt daleko wysuniętych wniosków. Owszem, klimat ten sam, ba, nawet w technikaliach gry znajdziemy wiele podobieństw (nawet zmienne w pliku konfiguracyjnym gry nazywane są bardzo podobnie), jednak Metro 2033 to typowy liniowy shooter, bardziej podobny do gier typu Half Life, niż Stalker.

Miałem to szczęście, że jako aktywny modder gry Stalker, oraz współtwórca rodzącego się serwisu metro-2033.pl, mogłem uczestniczyć w przedpremierowych beta-testach gry. Wrażenia z pobytu w siedzibie polskiego wydawcy i lokalizatora, CD Projekt, opisałem na łamach owego serwisu.

Czym się gra wyróżnia spośród innych? Jest tego kilka: postapokaliptyczny klimat, który wycieka z ekranu i głośników, piękna grafika, która wygląda tak jak wygląda nie tylko pod DirectX 11, które obsługuje, ale i również pod, uwaga, DirectX 9! Sama rozgrywka to, jak już wspomniałem, liniowy shooter. Na szczęście fabuła jest bardzo sprawnie poprowadzona i gra jest naprawdę ciekawa.

Wokół gry narobiło się bardzo dużo szumu z powodu dość niefortunnie przedstawionych przez THQ wymagań sprzętowych, które okazały się na szczęście dość mocno zawyżone (lepiej w sumie tak, niż na odwrót). Mój komputer to Pentium D @3,2GHz, 4GB RAM i karta GeForce 9600GT z 1GB RAMu. Gra w rozdzielczości 1280x1024 (bo w takich rozdzielczościach grywam) działa w okolicach 30 kl./s., momentami zwalniając do nieco powyżej 20 kl./s.

Ogółem... jeżeli ktoś lubi klimatyczne gry, które pozostawiają po sobie ślad - naprawdę szczerze polecam tę pozycję. Jeżeli jednak należysz do tych, którzy muszą mieć 120 kl./s. przy rozdzielczości Full-HD, a do tego wybór 150 rodzajów broni (nieważne, że każda do siebie podobna) - odradzam, to nie jest gra dla miłośników Call of Duty, czy Battle Field, serio.

#!/bin/bash

data=`date +%Y%m%d`
plik_baza=/home/utak3r/bazy/baza.gdb
plik_backup=/home/utak3r/backup/backup_$data.gbk

# backup bazy
if [ -e "$plik_backup" ]
then
	rm -f $plik_backup
fi
/opt/firebird/bin/gbak -b -g -l $plik_baza $plik_backup
if [ ! -e "$plik_backup" ]
then
	echo "Przerywam operacje."
	exit
fi
echo "Backup poprawny."

# pakowanie backupu
if [ -e "$plik_backup.bz2" ]
then

	rm -f "$plik_backup.bz2"
fi
/bin/bzip2 $plik_backup
if [ ! -e "$plik_backup.bz2" ]
then
	echo "Przerywam operacje."
	exit
fi
echo "Backup spakowany poprawnie."

# ftpujemy plik na serwer
plik_backup_bz2=$plik_backup.bz2

ftp -n utak3r.pl <<EOC
user login haslo
passive
binary
cd backupy_bazy
put ${plik_backup_bz2}
bye
EOC

echo "Plik skopiowany na FTP."

# ftpujemy plik na serwer
plik_backup_bz2=$plik_backup.bz2
akt_sciezka=`pwd`
backup_sciezka=${plik_backup_bz2%/*}
backup_basename=${plik_backup_bz2##*/}

# ftp może uploadowac pliki TYLKO z AKTUALNEGO katalogu !!!
cd $backup_sciezka

ftp -n utak3r.pl <<EOC
user login haslo
passive
binary
cd backupy_bazy
put ${backup_basename}
bye
EOC

cd $akt_sciezka
echo "Plik skopiowany na FTP."

Jak szybko i prosto otworzyć tunel po SSH? Okazuje się, że do prostych zadań wystarczy... znany wszystkim (chyba) programik PuTTY. Proces otwierania tunelu pokażę na przykładzie przekierowania portu 2401, czyli podpięciu się do serwera cvs. Po co tak? Załóżmy, że mamy w firmie serwer cvs, który nie jest wystawiony publicznie i jest dostępny jedynie w ramach sieci LAN firmy. Jeden warunek: musimy mieć konto shellowe na serwerze, z którym się będziemy tunelować.

Otwieramy PuTTY i wprowadzamy adres serwera i port SSH, po którym zazwyczaj się z nim łączymy, aby dojść do konsoli:

Przechodzimy teraz do zakładki Connection -> SSH -> Tunnels i definiujemy elementy tunelu.

Wybieramy opcję "local" i podajemy w "source port" port, który otworzymy na naszym komputerze, po czym w "destination" adres IP i port docelowy.

Klikamy przycisk "Add" i jesteśmy gotowi. Zapisujemy sesję na przyszły użytek (z poziomu zakładki "Sessions") i łączymy się i logujemy. Od tej pory mamy otwarty tunel na podany port. W podanym tutaj przykładzie, klientowi cvs podajemy, że serwer cvs znajduje się pod adresem 127.0.0.1:2401. Działa!