Hallo zusammen.
Ich habe vor ein paar tagen folgendes gefunden(anhang) und würde es
gerne nachbauen da es leider nicht mehr als bausatz zu kaufen gibt.
Ein smartcard-kode-schloss (Elektor 11/98, ich weiss ist schon ein
bißchen älter).
Ich habe schon länger interesse an elektrik/elektronik und habe
ausreichend lötkenntnisse um so eine schaltung zusammen zu löten aber
mein problem ist das ich keinerlei erfahrung mit programmierung(C,C++
usw.) habe.
Ich habe probiert mich selber schlau zu machen aber das internet ist so
voll mit tutorials und tips und tricks das ich garnicht weiß wo ich
anfangen soll zu lesen.
In der pdf steht "PBASIC-Listing des PIC-Programms vor der Kompilierung"
‘DUAL smart card lock with PIC16F84
‘copyright (c) 1998 Patrick GUEULLE
symbol f = B0
symbol g = B1
symbol e = B2
symbol r = B3
symbol BLINK = B4
symbol h = B5
DIRS = %11100110
PINS = %00000010
high 7
high 6
low 6
low 7
high 6
low 6
high 5
if PIN3 = 0 then learn
if PIN3 = 1 then check
learn:
for f = 0 to 31
e = 0
for g = 0 to 7
e = e * 2
e = e + PIN4
high 6
low 6
next g
h = 32 * PIN0
h = h + f
write h,e
next f
PINS = 0
BLINK = 50
goto led
check:
for f = 0 to 31
e = 0
for g = 0 to 7
e = e * 2
e = e + PIN4
high 6
low 6
next g
read f,r
if e <> r then other
goto cont
other:
h = f + 32
read h,r
if e <> r then error
cont:
next f
PINS = %00000110
goto forever
error:
PINS = 0
BLINK = 255
goto led
led:
for f = 0 to 10
high 1
pause BLINK
low 1
pause BLINK
next f
forever:
goto forever
Davon verstehe ich keine einzige zeile.
Jetzt meine frage.Kann mir irgendjemand das ganze in C
übersetzten(kompilieren würde ich mit mplab und cc5x grade so noch
hinkriegen) oder am besten schon ein fertiges hex-file zukommen lassen?
Laut der pdf ist das programm in pbasic verfaßt und ich hab bis jetzt
kein kompilierer für pbasic gefunden.Das brennen des pic`s würde ich zur
not auch noch hinbekommen.Hab da auch schon vieles drüber gelesen.
Bin dankbar um jede hilfe.
Mfg Maxe
> Davon verstehe ich keine einzige zeile.
ich auch nicht. Ohne Einrückung des Codes sieht das total schh****
..lecht aus. "ordnung ist das halbe Leben... " Mit Einrückungen
erschließt sich dir dann manche Zeile sofort von selbst.
Übrigens: Programmieren hat übrigens nix zwangsläufig mit irgendwelchen
bestimmten Programmiersprachen zu tun, genausowenig wie musikalisches
Verständnis nicht zwangsläufig an ein bestimmtes Musikinstrument
gekoppelt ist....
Versuch einfach die Logik (=den Algorithmus) der da hinter steckt zu
verstehen, dann gehts auch ganz einfach mit der Portierung auf jede
beliebige dir genehme Programmiersprache.
Das mit diesem üblen Basic "goto" rumgespringe solltest du dir auf jeden
Fall gar nicht angewöhnen, auch wenn manche C Dialekte sowas auch als
Befehl kennen.
Hier mal der Code in etwas eingerückt und lesbar. Ich hab schon mal
angefangen das ein wenig zu kommentieren. Den Rest bekommst du
sicherlich selbst hin ;-)
----------------------------------------
‘DUAL smart card lock with PIC16F84
‘copyright (c) 1998 Patrick GUEULLE
symbol f = B0
symbol g = B1
symbol e = B2
symbol r = B3
symbol BLINK = B4
symbol h = B5
DIRS = %11100110
PINS = %00000010
high 7
high 6
low 6
low 7
high 6
low 6
high 5
if PIN3 = 0 then learn
if PIN3 = 1 then check
learn:
for f = 0 to 31
e = 0
for g = 0 to 7
e = e * 2
e = e + PIN4
high 6
low 6
next g
h = 32 * PIN0
h = h + f
write h,e
next f
PINS = 0
BLINK = 50
goto led
check:
for f = 0 to 31
e = 0
for g = 0 to 7
e = e * 2
e = e + PIN4
high 6
low 6
next g
read f,r
if e <> r then other
goto cont
other:
h = f + 32
read h,r
if e <> r then error
cont:
next f
PINS = %00000110
goto forever
error:
PINS = 0
BLINK = 255
goto led
led:
for f = 0 to 10 ; wiederhole 11 mal
high 1 ; setze bit 1 auf "high"
pause BLINK ; mache eine Pause der Dauer BLINK
low 1 ; setze bit 1 auf "low"
pause BLINK ; mache eine Pause der Dauer BLINK
next f
forever:
goto forever ; eine sackgasse aus der keiner mehr rauskommt
@Wegstaben Verbuchsler
Würde Deine Mutter den Code verstehen, nun, wo Du in eingerückt hast?
Oder könnte Sie nun die fehlenden Kommentare einfügen?
Siehst Du. Das ist es was mich an manchen Programmierern so fasziniert:
Ihr fehlendes Einfühlungsvermögen.
Kannst Du nicht verstehen, was es bedeutet, wenn jemand sagt: "keinerlei
erfahrung mit programmierung"?
Klar. Jemand MIT Programmiererfahrung fängt sofort an, den Code
einzurücken.
Hallo nochmal.
@ Rainer
Hab ich schon probiert.Den bausatz gibt es nicht mehr.Wäre mir auch
lieber gewesen, denn so muss ich wohl oder übel programmieren lernen.
Aber trotzdem danke für deinen tipp.
@ Wegstaben Verbuchsler/Eddy Current
Das mit dem einrücken hat mir ehrlich gesagt einbißchen geholfen.
(hab mich einbißchen durchs internet durchgelesen (asm-c-c++ tutorials))
Aber wie -Eddy Current- schon sagte, für einen der noch nie mit
programmierung zutun hatte(vor 2 wochen angefangen) ist es verdammt
schwer da durch zu blicken.
Mein größtes problem im momment das ist daß ich nicht weiß was folgende
zeilen bedeuten:
symbol f = B0
symbol g = B1
symbol e = B2
symbol r = B3
symbol BLINK = B4
symbol h = B5
Um genau zu sein was das B0,B1,B2,B3,B4 und B5 hinter dem = heißen soll.
Ich denke irgendwelche register.Aber welche??
Wenn mir das einer erklären könnte dann könnte ich mir den rest schon
selber zusammen reimen.Hoffe ich.
Ich weiß was das "symbol" bedeutet(glaube ich).Das müsste das gleiche
sein wie in ASM das "EQU".(oder?)
Oder gibt es ein kompiler für pbasic?Am besten kostenlos.
@Maxe
gib mal in Google folgendes ein:
http://www.google.de/search?q=pbasic+symbol&ie=utf-8&oe=utf-8&aq=t&rls=org.mozilla:de:official&client=firefox-a
direkt der erste Link führt dich zu einem Dokument, welches die Nutzung
des PBASIC Dialekts beschreibt.
Übrigens wird die Programmiersprache Basic (speziell solche
"amputierten" basics wie das hier verwendete nicht zu unrecht als
ziemlich "bäh" angesehen. Sie hat sprachliche Besonderheiten die die
Transparenz eines Programmes nicht grade fördern
Zu deinem Verständnisproblem:
ja, genau erkannt. Die Stamp hat nur ein paar interne Speicherplätze für
Variablen. Damit man sie zuordnet bzw. mit einem "sprechernderen" Namen
ansprechen kann (ob Variablen mit einem Buchstaben so dolle sind sei
dahingestellt) gibt es die SYMBOL Anweisung
Hallo Leute.
Vielen dank erstmal für eure hilfe.
Ich habe in den letzten paar monaten viel gelesen und habe das ganze
Kartenschloss-Ding mal probiert in ASM zu schreiben.Um genauer zu sein
habe ich es erstmal in einer "abgespeckten version" probiert.
D.h. ich takte in dem programm keine karte an (das ist auch mein
problem,aber dazu später) sondern schreibe einfach,im ersten schritt,
die zahl 1 ins 1. EEPROM-Byte und die zahl 2 in die restlichen 31
EEPROM-Byte.Und im zweiten schritt vergleiche ich das ganze.
Klingt eigentlich simpel :-)
Hier der quelltext:
;**************************************************************
; PIC wählen und Includedatei für den 16F84 einbinden
list p=16F84
#include P16f84.INC
Errorlevel -302 ; Bank-Warnung ausschalten (asm)
;***************************************************************
;Konfiguration
__CONFIG _CP_OFF & _WDT_OFF & _PWRTE_ON & _RC_OSC
;***************************************************************
; Variablen und Constanten festlegen
;#define PORTA ; Chipkartendata an RA3
;#define rst PORTB,7 ; Chipkarte RESET
;#define clk PORTB,6 ; Chipkarte CLOCK
#define jumper PORTB,3 ; Jumper
#define ledR PORTB,5 ; Grüne LED
#define ledG PORTB,1 ; Rote LED
schleife1 equ 01h ; Schleifenzähler
;**************************************************************
; Startadresse
org 00h ; Startadresse
goto init
;**************************************************************
; Initialisierung der Port`s
init:
bsf STATUS,RP0 ; auf Bank 1 umschalten (TRISB)
movlw B'00011000' ; PORTB definiere
movwf TRISB
bcf STATUS,RP0 ; auf Bank 0 umschalten
goto start
;**************************************************************
; Programmstart
start:
btfsc jumper ; wenn RB3 nicht gestezt
goto schreiben
goto lesen ; dann gehe zu lesen
;**************************************************************
; Wenn Jumper gesteckt
schreiben:
bcf STATUS,RP0 ; Auf Bank 0 umschalten
movlw 20 ; Schleifenzähler laden
movwf schleife1
goto loop1
loop1:
movlw 20h ; Ich möchte EEPROM-Zelle 20h beschreiben
movwf EEADR ; schreibe 20h in EEADR
movlw 1 ; Eine 1 will ich da rein schreiben
movwf EEDATA
goto loop3
loop2:
bcf STATUS,RP0 ; Bank 0 umschalten (EEADR und EEDATA)
incf EEADR,1 ; EEPROM-Adresse um 1 erhöhen
movf EEADR,0
movwf EEADR
movlw 2 ; Eine 2 will ich da rein schreiben
movwf EEDATA
goto loop3
loop3:
bsf STATUS,RP0 ; auf Bank 1 umschalten (EECON1)
bsf EECON1,WREN ; nun ist Schreiben erlaubt
bcf EECON1,EEIF
movlw 0x55
movwf EECON2 ; schreibe 55h nach EECON2
movlw 0xAA
movwf EECON2 ; schreibe AAh nach EECON2
bsf EECON1,WR ; starte den Schreibzyklus
goto warte
warte: ; Warten bis
btfss EECON1,EEIF ; das EEPROM
goto warte ; beschrieben ist
goto weiter
weiter:
bcf STATUS,RP0 ; Auf Bank 0 umschalten
decfsz schleife1,1 ; Schleifenzähler 1 abziehen
goto loop2 ; wenn null dann gehe zu blink
goto blink
;************************************************************
; Wenn Jumper nicht gesteckt
lesen:
bcf STATUS,RP0 ; Bank 0
movlw 20 ; Schleifenzähler laden
movwf schleife1
goto loop4
loop4:
movlw 20h ; Ich will die EEPROM-Zelle
movwf EEADR ; 20h auslesen
bsf STATUS,RP0 ; auf Bank 1 umschalten (EECON1)
bsf EECON1,RD
bcf STATUS,RP0 ; Bank 0
movlw 1 ; Eine 1 ins W-Register schreiben
subwf EEDATA,0 ; Subtrahiere W von EEPROM
btfss STATUS,Z ; Ist das ergebnis gleich
goto RLED ; dann überspringe diesen befehl
goto loop6
loop5:
incf EEADR,1 ; EEPROM Adresse 1 erhöhen
movf EEADR,0
movwf EEADR
bsf STATUS,RP0 ; auf Bank 1 umschalten (EECON1)
bsf EECON1,RD ; Neue EEPROM-Adresse auslesen
bcf STATUS,RP0 ; Bank 0
movlw 2 ; Eine 2 ins W-Register schreiben
subwf EEDATA,0 ; Subtrahiere W von EEPROM
btfss STATUS,Z ; Ist das ergebnis gleich
goto RLED ; dann überspringe diesen befehl
decfsz schleife1,1 ; Schleifenzähler 1 abziehen
goto loop5 ; Wenn 32 byte gelesen
goto GLED ; dann gehe zu Grüne LED
loop6:
decf schleife1,1
goto loop5
;**************************************************************
; LED Blinken
blink:
bcf STATUS,RP0 ; auf Bank 0 umschalten (PORTB)
bsf ledG
nop ; Die NOP`s muss ich noch durch
nop ; warteschleifen ersätzen
bcf ´ ledG
nop
nop
goto blink ; endlosschleife
;**************************************************************
; Grüne und Rote LED
RLED:
bsf ledR
goto RLED
GLED:
bsf ledG
goto GLED
end
So,das ganze programm habe ich mit "MPLAB 8.10" fehlerfrei compiliren
können und habe dann die hex-file mal durch den "PIC Simulator IDE von
OshonSoft" gejagt.Das funktioniert einwandfrei.
Dazu 1 bild im anhang.
1 : EEPROM beschreiben
2 : EEPROM vergleichen (ist gleich)
3 : EEPROM vergleichen (ist ungleich)
Meine problem ist jetzt der teil wo es um die antaktung der karte geht.
Die karte reseten ist kein problem.
;************** Chipkarte reseten ******************************
bsf rst ; PORTB 7
bsf clk ; PORTB 6
bcf clk ; PORTB 6
bcf rst ; PORTB 7
;***************************************************************
Jedes weitere
bsf clk ; PORTB 6
bcf clk ; PORTB 6
erhöht den adresszähler der chipkarte und gibt dabei jedes mal eine bit
an I/0 raus.(?)
Ich hoffe ich habe es soweit richtig verstanden.
Aber wie kriege ich jetzt die 8 bit mit hilfe von RA3 in der richtigen
reihenfolge und ohne sie gegnseitig zu überschreiben in eine zelle?
Mit RRF oder RLF befehlen oder muss ich das ganze irgendwie verknüpfen?
Ich kriege das bis jetzt nicht hin.
Würde denn das programm so überhaupt laufen wenn ich es mit der
antaktung hinbekommen habe oder hat das programm irgendwelche
gravierende fehler?
Kann man solchen PIC Simulatoren trauen?
Bin um jede antwort dankbar.
MfG Maxe
Zuerst einmal Respekt für die Assemblerübersetzung.
Verschieben könnte eine Lösung sein: Nach Hinzufügen des eingelesenen
Bits in das niederwertigste Bit des Bytes, in dem das Ergebnis stehen
soll (Addition), könnte man das Ergebnisbyte eine Stelle nach links
verschieben und das nächste Bit hinzuaddieren.
Aber: Wenn das ganze wirklich PBASIC ist, hätte man doch einfach eine
Basic-Briefmarke (vorprogrammierter Controller von Parallax, erhältlich
z.B. bei Elektronikladen.de) verwenden können. Die alte, originale
Entwicklungssoftware (für DOS), mit der man das kompiliert und in den
EEPROM lädt, findet man noch, ggf. auch über Wilke, die das hier in
Deutschland vertrieben haben.
Solange der Code nach Übersetzung nicht größer als 64 Byte ist, geht
auch die kostenlose Lösung für PIC16F84, "BS4":
http://www.dontronics.com/bs4.html (unterer Abschnitt der Seite ist
relevant)
@Sebastian
Ich glaube der interne EEPROM-Bereich wird in dieser Applikation zum
Abspeichern der Code-Ziffern benutzt.
@Maxe
Hast du dir schon einmal MicroBasic von MikroElektronika angesehen:
http://www.mikroe.com/en/compilers/
