Hallo Zusammen, ich habe mal wieder ein Problem... ich arbeite gerade an einem Sicherheitsystem und möchte eine RFID Karte auslesen diese hat soviel ich weiß 10-12 Zahlen gespeichert ist ja alles kein Problem eine 10-12 Stellige Zahl über UART auszulesen aber ich möchte diese Zahl in einem Eeprom speichert was ja nun mal nur 8-bit hat. Wie kann ich die Zahl so kompriemieren das ich sie im Eeprom speichern und auslesen kann? Vielen Dank im Vorraus LG
ich schrieb: > in einem Eeprom speichert was ja nun mal nur 8-bit > hat 8 bit sind die Breite und NICHT die Tiefe des EEPROMS. Diese können mehrere Bytes mit 8-bit breite speichern.
ich schrieb: > möchte diese Zahl in einem Eeprom speichert was ja nun mal nur 8-bit > hat. Wie kann ich die Zahl so kompriemieren das ich sie im Eeprom Geht nicht. Du könntest sie aber durch 2 teilen und die beiden Hälften getrennt abspeichern.
Hallo, ich habe das mit dem 8-bit dann wohl falsch verstanden... werde das mit dem Teilen mal ausprobieren. LG
Hat keiner eine Lösung für das Problem? Oder ist dieser Beitrag einfach nur untergegangen? LG
ich schrieb: > möchte diese Zahl in einem Eeprom speichert was ja nun mal nur 8-bit > hat Mir ist dein Problem nicht ganz klar. Du sprichts von Bascom-Variablen und von speichern im EEPROM. Ich nehme einfach mal an, du meinst das EEPROM im AVR. Da gibt es überhaupt kein Problem, da du beliebige Variablen im EEPROM speichern kannst. Z.B. Dim B1 As Eram Byte , I1 As Eram Integer , S1(4) As Eram Single Dann beliebig lesen und schreiben (schreiben nicht zu oft). Aber wahrscheinlich liegt dein Problem wo anders. Das musst du dann genauer beschreiben.
Dein Problem ist das Du üblicherweise nur 8Bit variablen schreiben kannst, Du aber mit einer WORD Variable arbeitest. Das ist aber kein Problem. Es gibt sowas wie iByte und LoByte in Pascal, in Bascom und C ist es aber wohl genauso. Soll bedeuten.. die Zahl 255 in Byte entspricht ja 11111111 also 8 Stellen.. nun hast Du aber eine wert wie 1001010110101101 also 16 Stellen (WORD Variable) Nun hat also Deine Variabla X=12347 z.B. nun brauchst Du nur zu schreiben H:=x(HiByte); L:=x(LoByte); Du packst damit also die obersten 8 Zahlen in H und die unteren 8 in Lo Kannst also dies beiden Werte ganz einfach ins EEprom schreiben Wenn Du die nun wieder lesen wills,t musst Du natürlich den umgekehrten weg gehen also Hi und Lo lesen und mit X:=HiByte,H) und X:=LoByte,L) wieder in X packen.. Die Parameter stimmen jetzt beim lezten Beispiel nicht :-) Weiss egrade nicht mehr genau wie die in PAScal lauteten aber im PRinzip geht es so
Hallo, Ich habe ein externes i2c erproben und kann somit keine eRAM Variablen verwenden. Das mit dem High und Low verstehe ich nicht (bin noch Schüler...). Lg
Kim Schmidt schrieb: > Dein Problem ist das Du üblicherweise nur 8Bit variablen schreiben > kannst, Du aber mit einer WORD Variable arbeitest. Was macht ihr euch bloß für Probleme, die es gar nicht gibt. Das EEPROM ist genau so ein Speicher wie RAM und Flash. Organisiert in Byte aber beschreibbar mit beliebigen Variablen. Die stehen dann hintereinander so wie sie dimensioniert sind. In Bascom kann man das EEPROM mit Dim Variable as Eram Datentyp mit beliebigen Datentypen belegen. Mit der Byte-Organisation hat man überhaupt nichts zu tun, das geht ganz von selbst. Die einzige Besonderheit beim EEPROM ist, dass er nicht beliebig oft beschreibar ist. Lesen kann man ihn unbegrenzt.
Nur mal so. Ich lese meinen RFID-Leser via serielle aus und bekomme von ihm die ID des Chips welche aus 32bit besteht. Diese überträgt mein Leser als String im Hex-Format, also z.B. 41AA3B2F. Diese Nummer speichere ich einfacher halber als String im EEPROM ab. Ich könnte die ID in einem DWORD umwandeln und abspeichern was zwar nur 4 Bytes Platz braucht, aber das umrechnen ist ein ziemlicher Aufwand und mir zuviel. Da nehm ich die vier zusätzlichen Bytes in Kauf. Also speichere ich im EEPROM die Zeichen bzw. Werte:
1 | Char: 4 1 A A 3 B 2 F |
2 | Dez : 52 49 65 65 51 66 50 70 |
3 | Hex : 34 31 41 41 33 42 32 46 |
Dann brauche ich nur noch, wenn ich eine ID einlese, diesen String mit denen im EEPROM gespeicherten zu vergleichen und fertig. Funzt einfach und ohne Probleme. Und dadurch dass es ein String ist kann die ID sogar ein Text bzw. Passwort sein ohne dass man das Programm ändern muss. Wenn du mehrere IDs hast, musst du die natürlich in einer Schleife aus dem EEPROM an den entsprechenden Adressen auslesen. Das geht allerdings nicht durch Variablendefinition sondern nur durch byteweises Lesen des EEPROMS. Ich mach das gerne durch Overlay. Da kann ich als Byte einlesen und hab am Schluss einfach nen String, oder umgekehrt. Also z.B. so.
1 | Dim Eeprom_data As String * 9 ' Daten als String |
2 | Dim Eeprom_data_array(9) As Byte At Eeprom_data Overlay ' Daten als Array |
3 | |
4 | Eeprom_data="41AA3B2F" |
5 | Print Eeprom_data_array(1) ' 52 <= ASCII-Wert (Hex 34) |
6 | Print Eeprom_data_array(2) ' 49 |
7 | . |
8 | . |
9 | Print Eeprom_data_array(7) ' 50 |
10 | Print Eeprom_data_array(8) ' 70 |
11 | Print Eeprom_data_array(9) ' 0 <= Endzeichen für String |
12 | |
13 | oder umgekehrt |
14 | |
15 | Eeprom_data_array(2) = 67 |
16 | Print eeprom_data ' 4CAA3B2F |
Das Array wird zum speichern und lesen zum EEPROM genutzt und der String zum vergleichen. So, hoffe das hilft dir weiter.
Toni Nachname schrieb: > Hallo, > Ich habe ein externes i2c erproben und kann somit keine eRAM Variablen > verwenden. > Das mit dem High und Low verstehe ich nicht (bin noch Schüler...). > Zunächst musst du dich mit dem i2c bus auseinander setzen und lernen das externe eeprom zu beschalten. Software und beispiele findest du im Roboternetz bzw. In der Hilfe von Bascom. Fang doch aber erst einmal mit dem eeprom vom avr an zu spielen.
Hi Toni Nachname schrieb: > Hallo, > Ich habe ein externes i2c erproben und kann somit keine eRAM Variablen > verwenden. > Das mit dem High und Low verstehe ich nicht (bin noch Schüler...). > > Lg Nun, dann kann ich dir raten, dich erst einmal mit den Grundlagen von Bits und Bytes zu befassen. Du lernst in der Schule ja auch stufenweise und nicht mittendrin. Also nicht Wurzelziehen schon in der ersten Klasse, sondern erst einmal die Zahlen zu begreifen und vielleicht mal ein paar leichte Additionen. Zum Verständnis: ein Controller kann in der Regel grad mal 8 Bit als Byte verarbeiten. Nun gibt es aber Zahlen, die größer 255, das ist der größte Wert in 8 Bit, sind und da muss, wie im Dezimalsystem auch, wenn eine Zahl > 9 ist, eine weitere Stelle her. In diesem Fall ein zweites byte, ein High-Byte sozusagen. Damit haben wir 2, ein Lowbyte und ein Highbyte. Beide zusammen können nun einen Wert von 65535 darstellen oder wenn auch negativ, eben +32767 und -32768. Hast du nun eine 12 Bit Zahl, dann sieht das ja z.B. so aus 1011 1010 0111. Um daraus 2 Byte zu machen, wird das HighByte eben mit vorgestellten 0000 ergänzt. Somit hast du nun 0000 1011 1010 0111. Daraus folgt Highbyte = 0000 1011, Lowbyte = 1010 0111. Damit kann dein Controller auch umgehen, indem er die beiden Bytes eintsprechend einzeln behandelt und abspeichert. Wie das nun wieder geht, solltest du wissen. Ist ja dein Projekt. Gruß oldmax
na wenn man das aber gerade für ein Projekt benötigt geht es ja kaum das auch nächstes Jahr zu verschieben...Es gibt hier ja genug die es nicht beruflich brauchen, sondern lediglich ein Hobbyprojekt realisieren wollen, dann bringt das 1x1 nicht wirklich was..erstmal..
Hallo Zusammen, nochmal ich habe KEIN EEPROM das ich über eram ansteuern kann!!! Deshalb kann ich auch nicht ein Word Variable oder Integer oder so verwenden. Hier ist mein Code:
1 | '============I2C EEprom schreiben/lesen ================================== |
2 | |
3 | ' =========== Für 24C256 EEprom ===================== |
4 | ' 8MHz Quarz |
5 | ' LCD auf Port B , |
6 | ' |
7 | $regfile = "m32def.dat" |
8 | $crystal = 8000000 |
9 | |
10 | |
11 | 'SDA und SCL definieren |
12 | Config Sda = Portc.1 |
13 | Config Scl = Portc.0 |
14 | |
15 | |
16 | Dim X As Byte |
17 | Dim A As Byte |
18 | Dim B As Byte |
19 | Dim Lesen As Byte |
20 | CLS |
21 | |
22 | Do |
23 | '---- schreibe in EEprom ---- |
24 | For A = 1 To 10 |
25 | Incr X '1 bis Überlauf zählen |
26 | |
27 | I2cstart 'Start I2C |
28 | I2cwbyte &HA0 'Sende Slave Adresse |
29 | I2cwbyte 1 'Sende Speicheradresse High |
30 | I2cwbyte A 'Sende Speicheradresse LOw |
31 | I2cwbyte X 'Sende Wert |
32 | I2cstop 'Stop I2C |
33 | Waitms 10 'warte 10ms |
34 | |
35 | Locate 1 , 1 |
36 | Print "ins EEprom = " ; X ; " " ' Ausgabe der geschriebenen Werte am LCD |
37 | Waitms 500 |
38 | Next A |
39 | |
40 | |
41 | '--- lesen vom EEprom ---- |
42 | For B = 1 To 10 |
43 | |
44 | I2cstart 'Start I2C |
45 | I2cwbyte &HA0 'sende Slave Adresse |
46 | I2cwbyte 1 'sende Speicheradresse High |
47 | I2cwbyte B 'sende Speicheradresse Low |
48 | |
49 | I2cstart 'Start I2C |
50 | I2cwbyte &HA1 'sende Slave Adresse +1 für Lesen |
51 | I2crbyte Lesen , Nack 'lese Adresse vom EEprom |
52 | I2cstop 'Stop I2C |
53 | |
54 | Locate 2 , 1 |
55 | Print "Lese EEprom= " ; Lesen ; " " 'Ausgabe der EEprom Werte |
56 | Waitms 500 |
57 | Next B |
58 | |
59 | Loop |
60 | End |
Soll ich hier also mit den High und Low Speicheradressen arbeiten und wie kann ich die am besten Programmieren? Ich hoffe jetzt weiß jeder was gemeint ist. Aber trotzdem schon mal DANKE für die vielen Antworten LG
:
Bearbeitet durch User
Da steht genau das drin was du suchst. Zusammen mit den Infos von mir weiter oben sollte es jedem klar werden. ID des RFID-Chips als String in acht oder halt mehr Bytes abspeichern String als einzelne Bytes in EEPROM abspeichern Beim Suchen ab der ersten Adresse jeweils acht Bytes auslesen und vergleichen. Bei Gleichheit Tür auf, Hammer fallenlassen oder sonstwas. Und wenn du das ganze mit Zahlen machen willst, dann halt String via Hexval in DWORD und dann die Zahl ebenfalls in einzelnen Bytes, am besten auch via Overlay, ins EEPROM. Und zwar, wie im anderen Thread von mir geschrieben, ab Adresse Eeprom_adr. Und die kann von &H0000 (0 dez) bis &H7FFF (32767 dez) sein. Das High und Low erledigt das Overlay in der Deklaration. Wo ist das Problem aus den zwei Infos die richtige Antwort zu finden. Die Lösung steht doch im anderen Thread, brauchst nur die Adresse zu benutzen und dich um High und Low nicht zu kümmern. Und wie High und Low zusammengesetzt sind ergibt sich aus der Definition via DIM und Overlay. Und wenn das alles nicht klappt: RTFM!
:
Bearbeitet durch User
Du kannst im externen EEPROM Deine Daten immer nur byteweise ablegen. Hast Du z.B. ein zwei Byte großes Wort (Variablentyp Word oder Integer), dann zerlege es entweder in Highbyte und Lowbyte -> Befehl High/Low oder besser dimensioniere ein paar Variablen mit Overlay:
1 | dim BMA020_Byte(6) as byte |
2 | dim BMA020_integer(3) as integer at BMA020_Byte(1) overlay 'Index 1,3,5=> LB, 2.4.6 => HB |
hier wurden drei Integervariablen genutzt, die byteweise angesprochen werden können. Tom
Tom schrieb: > na wenn man das aber gerade für ein Projekt benötigt geht es ja kaum das > auch nächstes Jahr zu verschieben...Es gibt hier ja genug die es nicht > beruflich brauchen, sondern lediglich ein Hobbyprojekt realisieren > wollen, dann bringt das 1x1 nicht wirklich was..erstmal.. Nope. Wenn es an dieser Stelle Schwierigkeiten gibt, wie eine Aufteilung in Bytes vorzunehmen ist bzw. die Umkehrung, dann ist es viel zu früh über ein Projekt nachzudenken. Und dabei spielt es keine Rolle ob das beruflich oder privat ist. Ein gewisser Mindestlevel muss beherrscht werden, ansonsten hat das alles keinen Sinn. Genau das ist es, was man Grundlagen nennt.
:
Bearbeitet durch User
Hallo, Ich lerne ja immer weiter mit Bytes und Bits und so umzugehen ohne mir vorher eine Bibel übers programmieren gelesen zu haben. Und für mein Alter(12) reicht das meiner Meinung nach auch bin ja kein Ingenieur und habe das studiert
Hallo Joachim, hab gerade nochmal den alten Thread gelesen und dann den Code von dir gelesen werde den dann morgen mal ausprobieren und gucken ob es klappt. LG und DANKE DANKE für die Hilfe
Hi, Toni Nachname schrieb: > Und für mein > Alter(12) Also wenn das stimmt, nimm bitte einige Antworten nicht ganz so ernst. Wenn Du das gleich geschrieben hättest, wären einige Antworten sicher auch anders ausgefallen. In dem Alter fällt es sicher viel schwerer zu begreifen, warum zumindest ein paar Grundlagen so wichtig sind. Was Bit, Byte, Word und so bedeuten ist aber so grundlegend, daß Du Dir das vielleicht doch jetzt aneignen solltest. Wenn Du mit I2C, SPI oder Uart hantierst, schiebst Du auf einem AVR immer nur Bytes hin und her. Mit Glück baut Dir der Compiler oder eine Lib das zu grösseren Variablen zusammen oder zerlegt es zum Senden. Wenn Du aber nicht verstehst, was dahinter steckt, bist Du ziemlich verloren. In der Hilfe von Bascom sind die Variablentypen (für Bascom, das ist dann später übertragbar) ganz anständig beschrieben. Vielleicht verinnerlichst Du das erstmal. Lass den Teil mit Long und Double dabei erstmal weg. Gruß, Norbert
Hallo Norbert, ich schreibe nicht das ich 12 bin wenn ich es nicht wäre (wer macht das schon)... Wenn du für mich ein Buch bzw. eine gute Internetseite hast wo ich das lesen kann denn sage mir diese bitte. LG
Hi, ich hab sowas nicht zur Hand. Vielleicht solltest Du als allererstes mal die Zahlensysteme verstehen mit denen hier hantiert wird. Es sieht so aus als wenn Dir da so dermassen die Grundlagen fehlen, daß Du die meisten Antworten gar nicht verstehst. Versuche das erstmal rauszufinden. Der Beitrag in Wikipedia http://de.wikipedia.org/wiki/Hexadezimalsystem ist zwar nicht so toll aber man kann es grundsätzlich verstehen. Die Zahlensysteme sind aber nur eine unterschiedliche Schreibweise. Im Grunde geht es nur um Byte. Was Du vom Leser bekommst, sind 10-12 Byte, was die bedeuten hat Joachim geschrieben. Offensichtlich ist es ein 32-bit Wert der als Hex in Ascii übertragen wird. Wenn Du den letzten Satz wirklich verstanden hast, können wir weitermachen. Es macht wirklich keinen Sinn sowas zu versuchen wenn Du gar nicht verstehst mit was Du da hantierst. Hier über das Forum wird das eher nichts, weil Deine Fragen teilweise schon so unverständlich sind. Kannst Du nicht einen IT-Lehrer an Deiner Schule fragen, ob er Dir das mal erklärt? Oder Du suchst Dir einen Treff von "Makern" (mir fällt das Netzwerk gerade nicht ein), da ist bestimmt auch ein Netter, der sich mal ne halbe Stunde mit Dir hinsetzt. Gruß, Norbert
Hallo Norbert,
ich werde mir dazu dann nochmal irgendein Buch oder sowas lesen.
Habe aber nochmal eine Frage zu dem Code von Joachim: Wenn ich den Code
so umschreibe das er alle 3 Bytes liest funktioniert das zwar bei den
ersten zwei aber bei dem letzen nicht kann mir das jmd. helfen?
Mein Code:
$regfile = "m32def.dat"
$crystal = 8000000
$baud = 9600
'### Config EEPROM-Variablen
Const Eeprom_w = &HA0 'slave write
address
Const Eeprom_r = &HA1 'slave read
address
Dim Eeprom_count As Byte ' Zähler
Dim Eeprom_anz As Byte
Dim Eeprom_adr As Word ' Die
Adresse als Word-Variable
Dim Eeprom_high_adr As Byte At Eeprom_adr + 1 Overlay ' Zeiger auf
das High-Byte
Dim Eeprom_low_adr As Byte At Eeprom_adr Overlay ' Zeiger auf
das Low-Byte
Dim Eeprom_data As String * 27 ' Daten als
String
Dim Eeprom_data_array(27) As Byte At Eeprom_data Overlay ' Daten als
Array
Eeprom_data = "Dies ist ein Test "
Eeprom_anz = 21 ' 18 Zeichen
Eeprom_adr = &H0000 ' ab Adresse
0 schreiben
Config Sda = Portc.1 ' I2C-Port
festlegen
Config Scl = Portc.0 ' I2C-Port
festlegen
Print "Config Finshed"
Gosub Write_eeprom
Wait 1
Eeprom_anz = 7 ' 7 Zeichen
einlesen
Eeprom_adr = &H0000 ' Ab Adresse
0
Gosub Read_eeprom ' Nur "ist
ein" einlesen
Print Eeprom_data
Gosub Write_eeprom
Wait 1
Eeprom_anz = 7 ' 7 Zeichen
einlesen
Eeprom_adr = &H0007 ' Ab Adresse
8
Gosub Read_eeprom ' Nur "ist
ein" einlesen
Print Eeprom_data
Gosub Write_eeprom
Wait 1
Eeprom_anz = 7 ' 7 Zeichen
einlesen
Eeprom_adr = &H0014 ' Ab Adresse
15
Gosub Read_eeprom ' Nur "ist
ein" einlesen
Print Eeprom_data
End
'#######################################################################
##
'# Allgemeine Routine zum Lesen aus EEPROM
Read_eeprom:
For Eeprom_count = 1 To 24 'Daten
löschen
Eeprom_data_array(eeprom_count) = 0
Next Eeprom_count
I2cstart ' Generate
start code
I2cwbyte Eeprom_w ' send
address
I2cwbyte Eeprom_high_adr
I2cwbyte Eeprom_low_adr
I2cstart ' Generate
start code
I2cwbyte Eeprom_r ' send
address
For Eeprom_count = 1 To Eeprom_anz
If Eeprom_count = Eeprom_anz Then
I2crbyte Eeprom_data_array(eeprom_count) , Nack
Else
I2crbyte Eeprom_data_array(eeprom_count) , Ack
End If
Next Eeprom_count
I2cstop
Return
'#######################################################################
##
'# Allgemeine Routine zum Schreiben in EEPROM
Write_eeprom:
' Reset Eeprom_wp '
Schreibschutz aufheben
' Waitms 1
I2cstart ' Generate
start code
I2cwbyte Eeprom_w ' send
address
I2cwbyte Eeprom_high_adr
I2cwbyte Eeprom_low_adr
For Eeprom_count = 1 To Eeprom_anz
I2cwbyte Eeprom_data_array(eeprom_count)
Next Eeprom_count
I2cstop
Waitms 1
Return
LG
Hallo Toni, ich habe ehrlich gesagt jetzt keine Muße mehr da komplett durchzusteigen aber: Lass mal bitte erstmal die Finger von Overlay, wenn Du das noch nicht ganz verstanden hast. 2 Byte geht und 3 nicht riecht danach. Toni Nachname schrieb: > Dim Eeprom_adr As Word ' Die > Adresse als Word-Variable > Dim Eeprom_high_adr As Byte At Eeprom_adr + 1 Overlay ' Zeiger auf > das High-Byte > Dim Eeprom_low_adr As Byte At Eeprom_adr Overlay ' Zeiger auf > das Low-Byte Mit dem Word hast Du zwei Bytes die adressiert werden. Eeprom_adr ist die Adresse von dem Word. Eeprom_high_adr verweist auf die Adresse des oberen Bytes vom Word Eeprom_low_adr ist die Adresse des unteren Bytes. Mit 3 Byte geht das natürlich nicht. Irgendwie vermisse ich auch "$lib "i2c_twi.lbx", sonst geht I2C eigentlich nicht per Bascom. Da Du ja wohl Ambitionen hast: Mach bitte viel kleinere Schritte und verstehe jeden Schritt. µC ist nicht wie PC "hab rumprobiert und so geht es jetzt, mir egal warum". So funktioniert das nicht. Wenn Dir jetzt Jemand mit einem Codeschnipsel hilft und es dann funktioniert, ist Dir absolut nicht geholfen. Beim nächsten Projekt stehst Du genauso blöd da. Und versuche mal Deine Fragen komkreter zu stellen. "Dieser Code geht nicht" ist Mist. Was macht er? Was erwartest Du überhaupt was er machen soll? Wo ist der Unterschied zwischen dem Code der funktioniert und dem, der nicht funktioniert? So musst Du auch selbst an das Problem herangehen. Bei 12 Jahren ist das alles kein Vorwurf sondern eher bin ich beeindruckt, was Du da in Deinem Alter schon anstellst. Nach meiner Erfahrung könntest Du aber auch ein Student Wirtschaftsing. im Praktikum sein. So dachte vielleicht auch der Eine oder Andere hier. Technisch sind die auf ähnlichem Level und erzählen dann später den Ings, was sie entwickeln sollen... Ich glaube das aber mal einfach mit den 12 Jahren. Gruß, Norbert
Thread beobachten
Seitenaufteilung abschaltenBitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.