microgeek.eu

EPROM'owy projekt - wyświetlacz stanu szyny danych

bustra_ilu00.jpg

Jednym z zastosowań układów pamięci tylko do odczytu jest realizacja różnego rodzaju przekodowań, czyli zamiany jednego kodu liczbowego na inny. Opisane niżej urządzenie przetwarza liczbę 8-bitową na postać, która jest prezentowana na wyświetlaczu 7-segmentowym w kilku formatach zapisu. Trudno jest sobie wyobrazić prostsze rozwiązanie, w którym dokonywane są operacje pozwalające na zamianę jednego kodu na inny. Koncepcyjnie zagadnienie nie jest skomplikowane i możliwa jest jego realizacja w oparciu o typowe bramki logiczne. Jedyna trudność w sprzętowej realizacji dotyczy liczby potrzebnych układów logicznych. Sądzę, że duże kilkadziesiąt (może nawet kilkaset) bramek nie będzie liczbą przesadzoną. Użycie pamięci stałej sprowadza całość do zastosowania jednego układu (w sensie zespołu przetwarzającego kod).
Zadaniem urządzenia jest przedstawienie na 4-cyfrowym 7-segmentowym wyświetlaczu LED analizowanej liczby 8-bitowej (przykładowo 8-bitowe liczby są powszechnie stosowane w systemach mikroprocesorowych). Na liczbę reprezentowaną przez zbiór 8 stanów logicznych można spojrzeć na kilka sposobów:

liczbę w kodzie naturalnym binarnym wyświetloną w notacji szesnastkowej,
liczbę w kodzie naturalnym binarnym wyświetloną w notacji dziesiętnej,
liczbę w kodzie U2 wyświetloną w notacji dziesiętnej.

Poniższe urządzenie realizuje tą funkcjonalność. Składa się ono z kilku zespołów. Pierwszy zespół (rysunek 1) jest wejściowym 8-bitowym interfejsem równoległym.

bustra_ilu01.png

Stan szyny danych (reprezentowanej przez sygnały DAT0M .. DAT7M z rysunku 1) podlega dalszemu przetworzeniu.

bustra_ilu02.png

Dostarczona liczba do przekodowania (pamięć EPROM – układ U301, rysunek 2) jest przetworzona do wyświetlania multipleksowego. W oparciu o układ NE555 (U305, rysunek 2) zbudowany jest generator do takowania, przełączający wyświetlane cyfry w trybie multipleksowym. Impulsy z generatora są zliczana przez dwubitowy licznik (układ U303, rysunek 2) zbudowany w oparciu o przerzutniki typu D. Stan licznika określa numer aktualnie wyświetlanej w systemie multipleksowym cyfry na wyświetlaczu i jest doprowadzony do zespołu sterującego włączaniem kolejnych cyfr (układ U304 plus zespół tranzystorowy, rysunek 2). Jednocześnie informacja o numerze wyświetlanej cyfry jest doprowadzona do pamięci EPROM. Dodatkowo do pamięci dochodzi informacja (z zespołu obsługi klawiatury, rysunek 3) określająca w jakim systemie ma być wyświetlona liczba. Uzyskana z pamięci kombinacja poprzez układ ULN2803 (U302) dostarczona jest do zespołu wyświetlacza (reprezentowanego na schemacie złączem P301).Klawiatura działa w oparciu o proste przerzutniki RS w ten sposób, że naciśnięcie jednego z przycisków powoduje przejście danego przerzutnika do stanu wyróżnionego (stanem tym jest logiczne zero).
Schemat zespołu wyświetlacza pokazuje rysunek 4.

bustra_ilu03.png

Do kompletu dochodzi jeszcze moduł zasilacza, którego schemat pokazany jest na rysunku 5.Cała “magia” urządzenia zawarta jest w pamięci EPROM. By wyjaśnić zasadę działania należy popatrzeć na jej aplikację (rysunek 6).

bustra_ilu04.png

bustra_ilu07.jpg

Do pamięci dochodzi 8-bitowa liczba odzwierciedlająca monitorowaną szynę danych, numer wyświetlanej cyfry (z dzielnika modulo 4) oraz informacja o sposobie wyświetlenia (pochodząca z zespołu klawiatury). Doprowadzone do pamięci EPROM sygnały:

sygnały szyny danych mogą przyjmować każdy 8-bitowy stan,
sygnały określające numer cyfry mogą przyjmować każdy 2-bitowy stan,
sygnały trybu wyświetlania mogą przyjmować następujące stany: 110 dla wyświetlania szesnastkowego, 101 dla wyświetlania liczb dziesiętnych i 011 dla wyświetlania liczb ze znakiem.

bustra_ilu06.png

Z racji, że informacja o trybie wyświetlania nie wypełnia wszystkich możliwych kombinacji, pewne obszary w pamięci nie powinny (teoretycznie) być użyte i jako takie są wypełnione kodem odzwierciedlającym znak '-'.
Analizując schematy można zauważyć, że za sterowanie poszczególnymi segmentami wyświetlacza odpowiedzialne są następujące bity w pamięci EPROM:
Bit pamięci ↔ Segment cyfry
bit B0 ↔ A
bit B1 ↔ B
bit B2 ↔ C
bit B3 ↔ D
bit B4 ↔ E
bit B5 ↔ F
bit B6 ↔ G
bit B7 ↔ K (kropka)
Właściwie segment kropki nigdy nie zostanie wysterowany, więc może być pominięty w schematach (początkowo był przewidywany do sygnalizacji pracy poza dopuszczalnymi trybami, ale w efekcie ten stan jest sygnalizowany samymi minusami: segmentem G).
Sposób działania wyjaśnia następujący przykład:
Niech do wyświetlacza będzie doprowadzona liczba o następującym zapisie binarnym: 11111011. Ta liczba w zapisie szesnastkowym wynosi: FB, w zapisie dziesiętnym bez znaku jest to 251, w zapisie dziesiętnym ze znakiem jest to -5. W pamięci EPROM w komórkach o odpowiednich adresach muszą być zapisane następujące informacje:

bust_epromtab.png

Kolor reprezentuje tryb wyświetlania, kolor reprezentuje numer cyfry na wyświetlaczu, kolor reprezentuje szynę danych.
Do zaprogramowania pamięci EPROM należałoby wklepać bez pomyłki ponad osiem tysięcy liczb. Ponieważ zawartość pamięci jest regularna (to znaczy można podać algorytm określający co i gdzie ma znajdować się w pamięci), można opracować program, który wygeneruje zawartość pamięci (program PC-towy, który wygeneruje program, po skompilowaniu którego uzyskany zostanie wsad do pamięci EPROM). Jak zwykle w takiej sytuacji niezastąpione są języki typu asembler (istnieje absolutnie pełna kontrola nad umieszczanymi danymi) oraz można “ścigać pomyłki” przez uważną lekturę wygenerowanego kodu bez konieczności programowania pamięci (trzeba przyznać, że efekt końcowy nie został osiągnięty za pierwszym razem i tekst programu trzeba było kilka razy modyfikować).
Wygenerowany tekst programu do uzyskania wsadu do pamięci EPROM należy skompilować (i zlinkować) programem z pakietu AVSIM51. Tekst programu jest następujący (we fragmentach, gdyż lektura ponad ośmiu tysięcy wierszy nie jest zajęciem zbyt fascynującym):

Kod: Zaznacz cały

;
           NAME    DISPLAY
;
SEG_A      EQU     00000001B
SEG_B      EQU     00000010B
SEG_C      EQU     00000100B
SEG_D      EQU     00001000B
SEG_E      EQU     00010000B
SEG_F      EQU     00100000B
SEG_G      EQU     01000000B
SEG_K      EQU     10000000B
;
Minus      EQU SEG_G
Space      EQU 0
Digit_0    EQU SEG_A+SEG_B+SEG_C+SEG_D+SEG_E+SEG_F
Digit_1    EQU SEG_B+SEG_C
Digit_2    EQU SEG_A+SEG_B+SEG_D+SEG_E+SEG_G
Digit_3    EQU SEG_A+SEG_B+SEG_C+SEG_D+SEG_G
Digit_4    EQU SEG_B+SEG_C+SEG_F+SEG_G
Digit_5    EQU SEG_A+SEG_C+SEG_D+SEG_F+SEG_G
Digit_6    EQU SEG_A+SEG_C+SEG_D+SEG_E+SEG_F+SEG_G
Digit_7    EQU SEG_A+SEG_B+SEG_C
Digit_8    EQU SEG_A+SEG_B+SEG_C+SEG_D+SEG_E+SEG_F+SEG_G
Digit_9    EQU SEG_A+SEG_B+SEG_C+SEG_D+SEG_F+SEG_G
Digit_A    EQU SEG_A+SEG_B+SEG_C+SEG_E+SEG_F+SEG_G
Digit_B    EQU SEG_C+SEG_D+SEG_E+SEG_F+SEG_G
Digit_C    EQU SEG_A+SEG_D+SEG_E+SEG_F
Digit_D    EQU SEG_B+SEG_C+SEG_D+SEG_E+SEG_G
Digit_E    EQU SEG_A+SEG_D+SEG_E+SEG_F+SEG_G
Digit_F    EQU SEG_A+SEG_E+SEG_F+SEG_G
;
           ASEG
;
           ORG     0
;
     DB  Minus       ; adr=   0[0000]   sekc=??
     DB  Minus       ; adr=   1[0001]   sekc=??

(...)

     DB  Digit_0     ; adr=3192[0C78]   arg=120 sekc=U2  cyfra=0
     DB  Digit_1     ; adr=3193[0C79]   arg=121 sekc=U2  cyfra=0
     DB  Digit_2     ; adr=3194[0C7A]   arg=122 sekc=U2  cyfra=0
     DB  Digit_3     ; adr=3195[0C7B]   arg=123 sekc=U2  cyfra=0
     DB  Digit_4     ; adr=3196[0C7C]   arg=124 sekc=U2  cyfra=0
     DB  Digit_5     ; adr=3197[0C7D]   arg=125 sekc=U2  cyfra=0
     DB  Digit_6     ; adr=3198[0C7E]   arg=126 sekc=U2  cyfra=0
     DB  Digit_7     ; adr=3199[0C7F]   arg=127 sekc=U2  cyfra=0
     DB  Digit_8     ; adr=3200[0C80]   arg=-128 sekc=U2  cyfra=0
     DB  Digit_7     ; adr=3201[0C81]   arg=-127 sekc=U2  cyfra=0
     DB  Digit_6     ; adr=3202[0C82]   arg=-126 sekc=U2  cyfra=0
     DB  Digit_5     ; adr=3203[0C83]   arg=-125 sekc=U2  cyfra=0
     DB  Digit_4     ; adr=3204[0C84]   arg=-124 sekc=U2  cyfra=0
     DB  Digit_3     ; adr=3205[0C85]   arg=-123 sekc=U2  cyfra=0
     DB  Digit_2     ; adr=3206[0C86]   arg=-122 sekc=U2  cyfra=0

(...)

     DB  Digit_1     ; adr=3572[0DF4]   arg=-12 sekc=U2  cyfra=1
     DB  Digit_1     ; adr=3573[0DF5]   arg=-11 sekc=U2  cyfra=1
     DB  Digit_1     ; adr=3574[0DF6]   arg=-10 sekc=U2  cyfra=1
     DB  Minus       ; adr=3575[0DF7]   arg= -9 sekc=U2  cyfra=1
     DB  Minus       ; adr=3576[0DF8]   arg= -8 sekc=U2  cyfra=1
     DB  Minus       ; adr=3577[0DF9]   arg= -7 sekc=U2  cyfra=1
     DB  Minus       ; adr=3578[0DFA]   arg= -6 sekc=U2  cyfra=1
     DB  Minus       ; adr=3579[0DFB]   arg= -5 sekc=U2  cyfra=1
     DB  Minus       ; adr=3580[0DFC]   arg= -4 sekc=U2  cyfra=1
     DB  Minus       ; adr=3581[0DFD]   arg= -3 sekc=U2  cyfra=1
     DB  Minus       ; adr=3582[0DFE]   arg= -2 sekc=U2  cyfra=1
     DB  Minus       ; adr=3583[0DFF]   arg= -1 sekc=U2  cyfra=1
     DB  Space       ; adr=3584[0E00]   arg=  0 sekc=U2  cyfra=2
     DB  Space       ; adr=3585[0E01]   arg=  1 sekc=U2  cyfra=2
     DB  Space       ; adr=3586[0E02]   arg=  2 sekc=U2  cyfra=2
     DB  Space       ; adr=3587[0E03]   arg=  3 sekc=U2  cyfra=2
     DB  Space       ; adr=3588[0E04]   arg=  4 sekc=U2  cyfra=2
     DB  Space       ; adr=3589[0E05]   arg=  5 sekc=U2  cyfra=2
     DB  Space       ; adr=3590[0E06]   arg=  6 sekc=U2  cyfra=2

(...)

     DB  Minus       ; adr=3988[0F94]   arg=-108 sekc=U2  cyfra=3
     DB  Minus       ; adr=3989[0F95]   arg=-107 sekc=U2  cyfra=3
     DB  Minus       ; adr=3990[0F96]   arg=-106 sekc=U2  cyfra=3
     DB  Minus       ; adr=3991[0F97]   arg=-105 sekc=U2  cyfra=3
     DB  Minus       ; adr=3992[0F98]   arg=-104 sekc=U2  cyfra=3
     DB  Minus       ; adr=3993[0F99]   arg=-103 sekc=U2  cyfra=3
     DB  Minus       ; adr=3994[0F9A]   arg=-102 sekc=U2  cyfra=3
     DB  Minus       ; adr=3995[0F9B]   arg=-101 sekc=U2  cyfra=3
     DB  Minus       ; adr=3996[0F9C]   arg=-100 sekc=U2  cyfra=3
     DB  Space       ; adr=3997[0F9D]   arg=-99 sekc=U2  cyfra=3
     DB  Space       ; adr=3998[0F9E]   arg=-98 sekc=U2  cyfra=3
     DB  Space       ; adr=3999[0F9F]   arg=-97 sekc=U2  cyfra=3
     DB  Space       ; adr=4000[0FA0]   arg=-96 sekc=U2  cyfra=3
     DB  Space       ; adr=4001[0FA1]   arg=-95 sekc=U2  cyfra=3
     DB  Space       ; adr=4002[0FA2]   arg=-94 sekc=U2  cyfra=3
     DB  Space       ; adr=4003[0FA3]   arg=-93 sekc=U2  cyfra=3

(...)

     DB  Digit_0     ; adr=5370[14FA]   arg=250 sekc=NB  cyfra=0
     DB  Digit_1     ; adr=5371[14FB]   arg=251 sekc=NB  cyfra=0
     DB  Digit_2     ; adr=5372[14FC]   arg=252 sekc=NB  cyfra=0
     DB  Digit_3     ; adr=5373[14FD]   arg=253 sekc=NB  cyfra=0
     DB  Digit_4     ; adr=5374[14FE]   arg=254 sekc=NB  cyfra=0
     DB  Digit_5     ; adr=5375[14FF]   arg=255 sekc=NB  cyfra=0
     DB  Space       ; adr=5376[1500]   arg=  0 sekc=NB  cyfra=1
     DB  Space       ; adr=5377[1501]   arg=  1 sekc=NB  cyfra=1
     DB  Space       ; adr=5378[1502]   arg=  2 sekc=NB  cyfra=1
     DB  Space       ; adr=5379[1503]   arg=  3 sekc=NB  cyfra=1
     DB  Space       ; adr=5380[1504]   arg=  4 sekc=NB  cyfra=1
     DB  Space       ; adr=5381[1505]   arg=  5 sekc=NB  cyfra=1
     DB  Space       ; adr=5382[1506]   arg=  6 sekc=NB  cyfra=1
     DB  Space       ; adr=5383[1507]   arg=  7 sekc=NB  cyfra=1
     DB  Space       ; adr=5384[1508]   arg=  8 sekc=NB  cyfra=1
     DB  Space       ; adr=5385[1509]   arg=  9 sekc=NB  cyfra=1
     DB  Digit_1     ; adr=5386[150A]   arg= 10 sekc=NB  cyfra=1
     DB  Digit_1     ; adr=5387[150B]   arg= 11 sekc=NB  cyfra=1
     DB  Digit_1     ; adr=5388[150C]   arg= 12 sekc=NB  cyfra=1
     DB  Digit_1     ; adr=5389[150D]   arg= 13 sekc=NB  cyfra=1

(...)

     DB  Digit_4     ; adr=6388[18F4]   arg=F4 sekc=hex cyfra=0
     DB  Digit_5     ; adr=6389[18F5]   arg=F5 sekc=hex cyfra=0
     DB  Digit_6     ; adr=6390[18F6]   arg=F6 sekc=hex cyfra=0
     DB  Digit_7     ; adr=6391[18F7]   arg=F7 sekc=hex cyfra=0
     DB  Digit_8     ; adr=6392[18F8]   arg=F8 sekc=hex cyfra=0
     DB  Digit_9     ; adr=6393[18F9]   arg=F9 sekc=hex cyfra=0
     DB  Digit_A     ; adr=6394[18FA]   arg=FA sekc=hex cyfra=0
     DB  Digit_B     ; adr=6395[18FB]   arg=FB sekc=hex cyfra=0
     DB  Digit_C     ; adr=6396[18FC]   arg=FC sekc=hex cyfra=0
     DB  Digit_D     ; adr=6397[18FD]   arg=FD sekc=hex cyfra=0
     DB  Digit_E     ; adr=6398[18FE]   arg=FE sekc=hex cyfra=0
     DB  Digit_F     ; adr=6399[18FF]   arg=FF sekc=hex cyfra=0
     DB  Digit_0     ; adr=6400[1900]   arg=00 sekc=hex cyfra=1
     DB  Digit_0     ; adr=6401[1901]   arg=01 sekc=hex cyfra=1
     DB  Digit_0     ; adr=6402[1902]   arg=02 sekc=hex cyfra=1
     DB  Digit_0     ; adr=6403[1903]   arg=03 sekc=hex cyfra=1
     DB  Digit_0     ; adr=6404[1904]   arg=04 sekc=hex cyfra=1
     DB  Digit_0     ; adr=6405[1905]   arg=05 sekc=hex cyfra=1
     DB  Digit_0     ; adr=6406[1906]   arg=06 sekc=hex cyfra=1

(...)

     DB  Minus       ; adr=8189[1FFD]   sekc=??
     DB  Minus       ; adr=8190[1FFE]   sekc=??
     DB  Minus       ; adr=8191[1FFF]   sekc=??
     END

Po zaprogramowaniu pamięci EPROM, urządzenie gotowe jest do pracy.

bustra_ilu08.jpg

Pamiętając, że interfejs wejściowy ma rezystory wstępnego wymuszenia stanu logicznej jedynki, po włączeniu na wyświetlaczu pokazywana jest następująca informacja:

bustra_ilu09.jpg

bustra_ilu10.jpg

bustra_ilu11.jpg

bustra_ilu12.jpg

bustra_ilu13.jpg

bustra_ilu14.jpg

bustra_ilu15.jpg

bustra_ilu16.jpg

Oczywiście wklepanie ośmiu tysięcy wierszy bez pomyłki graniczy z cudem (cudów nie ma są tylko dziwy), więc w celu uzyskania kodu źródłowego odpowiadającego zawartości EPROM należy napisać prosty program. Jego zadaniem będzie wygenerowanie tekstu programu do kompilacji, w wyniku której uzyskany zostaje kod do umieszczenia w EPROM. Program został napisany w TURBO PASCALU (a jego kompilator obecnie można bezpłatnie pobrać z internetu).

Kod: Zaznacz cały

program Display ;

  const
    TableSize   = 8191 ;

    HexDisplacement = $1800 ; (* 110zzxxxxxxxx 1800 = *)
    NBDisplacement = $1400 ;  (* 101zzxxxxxxxx 1400 = *)
    U2Displacement = $0C00 ;  (* 011zzxxxxxxxx 0C00 = *)

  var
    OutF : text ;
    DataTable : array [ 0 .. TableSize ] of char ;
    Loop : integer ;
    DataB0 : char ;
    DataB1 : char ;
    DataB2 : char ;
    DataB3 : char ;

function HexCh ( HexNumber : integer ) : char ;
  var
    Ch : char ;
  begin
    Ch := '?' ;
    case HexNumber of
       0 : Ch := '0' ;
       1 : Ch := '1' ;
       2 : Ch := '2' ;
       3 : Ch := '3' ;
       4 : Ch := '4' ;
       5 : Ch := '5' ;
       6 : Ch := '6' ;
       7 : Ch := '7' ;
       8 : Ch := '8' ;
       9 : Ch := '9' ;
      10 : Ch := 'A' ;
      11 : Ch := 'B' ;
      12 : Ch := 'C' ;
      13 : Ch := 'D' ;
      14 : Ch := 'E' ;
      15 : Ch := 'F' ;
    end (* case *) ;
    HexCh := Ch ;
  end (* HexCh *) ;

procedure ConvU2 ( Number : integer ) ;
  var
    ModV : integer ;
    Minus : boolean ;
  begin
    Minus := false ;
    if Number < 0 then
    begin
      Minus := true ;
      Number := - Number ;
    end (* if *) ;
    DataB1 := ' ' ;
    DataB2 := ' ' ;
    DataB3 := ' ' ;
    ModV := Number mod 10 ;
    Number := Number div 10 ;
    DataB0 := HexCh ( ModV ) ;
    if Minus then
      DataB1 := '-' ;
    if Number <> 0 then
    begin
      ModV := Number mod 10 ;
      Number := Number div 10 ;
      DataB1 := HexCh ( ModV ) ;
      if Minus then
        DataB2 := '-' ;
      if Number <> 0 then
      begin
        ModV := Number mod 10 ;
        DataB2 := HexCh ( ModV ) ;
        if Minus then
          DataB3 := '-' ;
      end (* if *) ;
    end (* if *) ;
  end (* ConvU2 *) ;


procedure ConvNB ( Number : integer ) ;
  var
    ModV : integer ;
  begin
    DataB1 := ' ' ;
    DataB2 := ' ' ;
    DataB3 := ' ' ;
    ModV := Number mod 10 ;
    Number := Number div 10 ;
    DataB0 := HexCh ( ModV ) ;
    if Number <> 0 then
    begin
      ModV := Number mod 10 ;
      Number := Number div 10 ;
      DataB1 := HexCh ( ModV ) ;
      if Number <> 0 then
      begin
        ModV := Number mod 10 ;
        DataB2 := HexCh ( ModV ) ;
      end (* if *) ;
    end (* if *) ;
  end (* ConvNB *) ;

procedure ConvHex ( Number : integer ) ;
  begin
    DataB0 := HexCh ( Number MOD 16 ) ;
    DataB1 := HexCh ( Number DIV 16 ) ;
    DataB2 := ' ' ;
    DataB3 := ' ' ;
  end (* ConvHex *) ;

procedure GenTable_Hex ;
  var
    Number : integer ;
  begin
    for Number := 0 to 255 do
    begin
      ConvHex ( Number ) ;
      DataTable [ Number + HexDisplacement + 0 ] := DataB0 ;
      DataTable [ Number + HexDisplacement + 256 ] := DataB1 ;
      DataTable [ Number + HexDisplacement + 512 ] := DataB2 ;
      DataTable [ Number + HexDisplacement + 768 ] := DataB3 ;
    end (* for *) ;
  end (* GenTable_Hex *) ;

procedure GenTable_NB ;
  var
    Number : integer ;
  begin
    for Number := 0 to 255 do
    begin
      ConvNB ( Number ) ;
      DataTable [ Number + NBDisplacement + 0 ] := DataB0 ;
      DataTable [ Number + NBDisplacement + 256 ] := DataB1 ;
      DataTable [ Number + NBDisplacement + 512 ] := DataB2 ;
      DataTable [ Number + NBDisplacement + 768 ] := DataB3 ;
    end (* for *) ;
  end (* GenTable_NB *) ;


procedure GenTable_U2 ;
  var
    Number : integer ;
    Index : integer ;
  begin
    for Number := -128 to 127 do
    begin
      Index := Number ;
      if Index < 0 then
        Index := Index + 256 ;
      ConvU2 ( Number ) ;
      DataTable [ Index + U2Displacement + 0 ] := DataB0 ;
      DataTable [ Index + U2Displacement + 256 ] := DataB1 ;
      DataTable [ Index + U2Displacement + 512 ] := DataB2 ;
      DataTable [ Index + U2Displacement + 768 ] := DataB3 ;
    end (* for *) ;
  end (* GenTable_U2 *) ;


procedure AddComment ( Number : integer ) ;
  var
    Section : integer ;
    Arg : integer ;
    Digit : integer ;
  begin
    Section := Number DIV 1024 ;
    Arg := Number MOD 256 ;
    Digit := ( Number DIV 256 ) MOD 4 ;
    Write ( OutF , ' adr=' , Number : 4 , '[' ) ;
    Write ( OutF , HexCh ( Number DIV 4096 ) ) ;
    Write ( OutF , HexCh ( ( Number MOD 4096 ) DIV 256 ) ) ;
    Write ( OutF , HexCh ( ( Number MOD 256 ) DIV 16 ) ) ;
    Write ( OutF , HexCh ( Number MOD 16 ) ) ;
    Write ( OutF , ']  ' ) ;
    if Section = 6 then
    begin
      Write ( OutF , ' arg=' , HexCh ( Arg DIV 16 ) , HexCh ( Arg MOD 16 ) , ' sekc=hex cyfra=' , Digit ) ;
      WriteLn ( OutF ) ;
      exit ;
    end (* if *) ;
    if Section = 5 then
    begin
      Write ( OutF , ' arg=' , Arg:3 , ' sekc=NB  cyfra=' , Digit ) ;
      WriteLn ( OutF ) ;
      exit ;
    end (* if *) ;
    if Section = 3 then
    begin
      if Arg >= 128 then
        Arg := Arg - 256 ;
      Write ( OutF , ' arg=' , Arg:3 , ' sekc=U2  cyfra=' , Digit ) ;
      WriteLn ( OutF ) ;
      exit ;
    end (* if *) ;
    Write ( OutF , ' sekc=??' ) ;
    WriteLn ( OutF ) ;
  end (* AddComment *) ;

begin
  Assign ( OutF , 'DISPL.S03' ) ;
  Rewrite ( OutF ) ;
  Writeln ( OutF , ';' ) ;
  Writeln ( OutF , '           NAME    DISPLAY' ) ;
  Writeln ( OutF , ';' ) ;
  Writeln ( OutF , 'SEG_A      EQU     00000001B' ) ;
  Writeln ( OutF , 'SEG_B      EQU     00000010B' ) ;
  Writeln ( OutF , 'SEG_C      EQU     00000100B' ) ;
  Writeln ( OutF , 'SEG_D      EQU     00001000B' ) ;
  Writeln ( OutF , 'SEG_E      EQU     00010000B' ) ;
  Writeln ( OutF , 'SEG_F      EQU     00100000B' ) ;
  Writeln ( OutF , 'SEG_G      EQU     01000000B' ) ;
  Writeln ( OutF , 'SEG_K      EQU     10000000B' ) ;
  Writeln ( OutF , ';' ) ;
  Writeln ( OutF , 'Minus      EQU SEG_G' ) ;
  Writeln ( OutF , 'Space      EQU 0' ) ;
  Writeln ( OutF , 'Digit_0    EQU SEG_A+SEG_B+SEG_C+SEG_D+SEG_E+SEG_F' ) ;
  Writeln ( OutF , 'Digit_1    EQU SEG_B+SEG_C' ) ;
  Writeln ( OutF , 'Digit_2    EQU SEG_A+SEG_B+SEG_D+SEG_E+SEG_G' ) ;
  Writeln ( OutF , 'Digit_3    EQU SEG_A+SEG_B+SEG_C+SEG_D+SEG_G' ) ;
  Writeln ( OutF , 'Digit_4    EQU SEG_B+SEG_C+SEG_F+SEG_G' ) ;
  Writeln ( OutF , 'Digit_5    EQU SEG_A+SEG_C+SEG_D+SEG_F+SEG_G' ) ;
  Writeln ( OutF , 'Digit_6    EQU SEG_A+SEG_C+SEG_D+SEG_E+SEG_F+SEG_G' ) ;
  Writeln ( OutF , 'Digit_7    EQU SEG_A+SEG_B+SEG_C' ) ;
  Writeln ( OutF , 'Digit_8    EQU SEG_A+SEG_B+SEG_C+SEG_D+SEG_E+SEG_F+SEG_G' ) ;
  Writeln ( OutF , 'Digit_9    EQU SEG_A+SEG_B+SEG_C+SEG_D+SEG_F+SEG_G' ) ;
  Writeln ( OutF , 'Digit_A    EQU SEG_A+SEG_B+SEG_C+SEG_E+SEG_F+SEG_G' ) ;
  Writeln ( OutF , 'Digit_B    EQU SEG_C+SEG_D+SEG_E+SEG_F+SEG_G' ) ;
  Writeln ( OutF , 'Digit_C    EQU SEG_A+SEG_D+SEG_E+SEG_F+SEG_G' ) ;
  Writeln ( OutF , 'Digit_D    EQU SEG_B+SEG_C+SEG_D+SEG_E+SEG_G' ) ;
  Writeln ( OutF , 'Digit_E    EQU SEG_A+SEG_D+SEG_E+SEG_F+SEG_G' ) ;
  Writeln ( OutF , 'Digit_F    EQU SEG_A+SEG_E+SEG_F+SEG_G' ) ;
  Writeln ( OutF , ';' ) ;
  Writeln ( OutF , '           ASEG' ) ;
  Writeln ( OutF , ';' ) ;
  Writeln ( OutF , '           ORG     0' ) ;
  Writeln ( OutF , ';' ) ;
  for Loop := 0 to TableSize do
  begin
    DataTable [ Loop ] := '-' ;
  end (* for *) ;
  GenTable_Hex ;
  GenTable_NB ;
  GenTable_U2 ;
  for Loop := 0 to TableSize do
  begin
    Write ( OutF , '     DB  ' ) ;
    case DataTable [ Loop ] of
      '-' : Write ( OutF , 'Minus       ;' ) ;
      ' ' : Write ( OutF , 'Space       ;' ) ;
      '0' : Write ( OutF , 'Digit_0     ;' ) ;
      '1' : Write ( OutF , 'Digit_1     ;' ) ;
      '2' : Write ( OutF , 'Digit_2     ;' ) ;
      '3' : Write ( OutF , 'Digit_3     ;' ) ;
      '4' : Write ( OutF , 'Digit_4     ;' ) ;
      '5' : Write ( OutF , 'Digit_5     ;' ) ;
      '6' : Write ( OutF , 'Digit_6     ;' ) ;
      '7' : Write ( OutF , 'Digit_7     ;' ) ;
      '8' : Write ( OutF , 'Digit_8     ;' ) ;
      '9' : Write ( OutF , 'Digit_9     ;' ) ;
      'A' : Write ( OutF , 'Digit_A     ;' ) ;
      'B' : Write ( OutF , 'Digit_B     ;' ) ;
      'C' : Write ( OutF , 'Digit_C     ;' ) ;
      'D' : Write ( OutF , 'Digit_D     ;' ) ;
      'E' : Write ( OutF , 'Digit_E     ;' ) ;
      'F' : Write ( OutF , 'Digit_F     ;' ) ;
    end (* case *) ;
    AddComment ( Loop ) ;
  end (* for *) ;
  Writeln ( OutF , '        END' ) ;
  Close ( OutF ) ;
end.

Powyższy program

DISPLAY.ZIP

po uruchomieniu generuje postać źródłową do EPROM'u.

displ_asm.zip

Ten po kompilacji daje zawartość EPROM.

displ_hex.zip

Pozostało zaprogramować EPROM.

Z czasem powyższy układ metodą pilnika i wiertarki (masakra

) doczekał się obudowy.

IMG_5537.JPG

IMG_5538.JPG

IMG_5539.JPG

IMG_5540.JPG

IMG_5541.JPG

IMG_5542.JPG

IMG_5543.JPG

IMG_5544.JPG

Pamiętając, że pozycja ON w dipswitch łączy styki, czyli tu zwiera do masy :arrow:

daje "0".

IMG_5548.JPG

Trochę go używałem:

IMG_5545.JPG

IMG_5546.JPG

IMG_5547.JPG

IMG_5549.JPG

IMG_5551.JPG

Aż przyszła ochota na więcej. Układ przeszedł fazę redesign-u. W nowej postaci jeszcze nie jest zupełnie ready, ale wkrótce urodzi się nowe

IMG_5552.JPG

IMG_5553.JPG

O czym postaram się poinformować.

Jakie ty masz fajne pudełko na to, no wow!
Tylko smugi po szlifowaniu ci widać na froncie, ale wiesz co - bierze się pumeks kosmetyczny, taki jak do stóp i na niego większą odrobinę mleczka CIF i tym w strumieniu wody myziasz - to odpowiada papierowi ściernemu 800..1000, mega delikatny jest,
No a potem oczywiście czarny, matowy spray na front.

Do czego taki wielki wyświetlacz? Adres i dane naraz? No weź pokaż schemat.

ps
u mnie w fabryce wszędzie stelaże do eurocard, normalnie obsesja jakaś, chyba sobie do domu tez taki sprawie, będę miała swojsko....

tasza pisze:Jakie ty masz fajne pudełko na to, no wow!

Takie metalowe pudełka kiedyś były do kupienia. Kojarzysz tego typu obudówki?

IMG_5556.JPG

Ja robiłem jedynie czołówkę z alu, jak była bardziej złożona. Jak prosta, to wykorzystywałem oryginale. Dziurki okrągłe to pikuś :arrow:

wiertarka. Pod złącza DB to mam wykrojnik do DB9. Jak walnąć dwa obok siebie, to da się zrobić nawet do DB<ile chcesz>. Fota pokazuje mój emulator EPROM.
Fajniej wyglądają urządzenia w "niskoprofilowej" obudowie, więc oryginalne pokrywy skracałem na gilotynie.
Teraz robię trochę inaczej.
Próbka:

IMG_5554.JPG

O szczegółach :arrow:

później.

tasza pisze:Tylko smugi po szlifowaniu ci widać na froncie, ale wiesz co - bierze się pumeks kosmetyczny, taki jak do stóp i na niego większą odrobinę mleczka CIF i tym w strumieniu wody myziasz - to odpowiada papierowi ściernemu 800..1000, mega delikatny jest,
No a potem oczywiście czarny, matowy spray na front.

Nie natrafiłem na spray, który by trzymał się alu, ale ... może słabo szukałem.
W tym przypadku smugi są efektem zamierzonym. Robisz to tak: szlifierka oscyjacyjna + papier typu 150. Robi takie koliste smugi. Przy okazji zaciera wszystkie większe rysy po pilniku i innych narzędziach i wypadkach, gdzie coś w sposób niezamierzony zostawiło swój ślad. Taki był zamiar. W przyszłości nie omieszkam wypróbować twego rozwiązania

Reszta

trochę cierpliwości.

no to teraz breaking news / załamujące wiadomości,
wracamy z Tośką z jej SQL noga za nogą przez osiedle i gadamy o facetach, a tu nagle na śmietniku .... :shock:

CAM01254.jpg

CAM01255.jpg

CAM01256.jpg

to jest jakieś coś do telewizji kablowej chyba, nie wiem, i don't care - ale obudowa z aluminium i przednia płyta do modyfikacji, reszta potem, jak to rozmontujemy na kawałki to pokaże

tasza pisze:... a tu nagle na śmietniku ....

Ty to masz farta. Zbierasz na śmietnikach same kruki (czasem białe) :mrgreen:

no farta mam, ale i możliwe, że niedyplomatycznie nieco wyszło, bo moja Młoda podpatruje i powiela zachowania... choć w sumie...staram się jej zaszczepić szacunek dla tego co dobre, trwałe i przydatne do ponownego użycia...anyway zabawę na wieczór mamy gwarantowaną

tasza pisze:...bo moja Młoda podpatruje i powiela zachowania...

To ma najlepsze w galaktyce wzorce do naśladowania.

ale płyną od w sumie obcej osoby a nie rodziców i to jest cholernie krzywe

zostawmy to Andrzej, ok? ja nie chce napisać czegoś, co potem będę żałować.....

tasza pisze:obcej osoby a nie rodziców i to jest cholernie krzywe

Wszystkie dzieci są nasze... ale zostawmy to, bo robi się offtopowo

microgeek.eu

EPROM - wyświetlacz szyny danych

EPROM - wyświetlacz szyny danych

Re: EPROM - wyświetlacz szyny danych

Re: EPROM - wyświetlacz szyny danych

Re: EPROM - wyświetlacz szyny danych

Re: EPROM - wyświetlacz szyny danych

Re: EPROM - wyświetlacz szyny danych

Re: EPROM - wyświetlacz szyny danych

Re: EPROM - wyświetlacz szyny danych

Re: EPROM - wyświetlacz szyny danych

Re: EPROM - wyświetlacz szyny danych