What I don't understand is that the sd card is not recognized. It doesn't appeared in the file browser.
I have received the adapter to convert sd to microsd card but it's not recognized by smartphone Huawei P9 Lite.
Hallo jori,
kannst du mal verraten ob du beim senden des Passwortes an die Karte, dieses so sendest wie es eingegeben wurde oder ob du vor dem Senden eine lower oder uppercase Umwandlung machst.
Und was mich auch interessieren würde, warum die Prüfsumme der CID immer mit 00 ausgegeben wird obwohl eine andere Prüfsumme geschrieben wurde (hat jetzt nichts mit cmd42 zu tun aber mit mmc und vielleicht weiss es jemand)
Hintergrund: ich habe 1b534d454231515430ba2f5f9f0114fd mit "mmc prog_cid" geschrieben aber ausgelesen/angezeigt wurde 1b534d454231515430ba2f5f9f011400
@Link nur für registrierte und freigeschaltete Mitglieder sichtbar. - das passwort wird unverändert an die sd-karte gesendet. gross.- und kleinschreibung ist also zu beachten.
die ersten beiden stellen sind die prüfsumme der CID und werden so ausgegeben, wie sie von der sd-karte gesendet wurde.
ganz genau genommen sind es nur die oberen 7 bit des ersten bytes, die eine crc7-checksumme darstellen. bit NULL der CID ist ungenutzt und sollte eigentlich immer auf 1 stehen.
mfg jori...
das verstehe ich nicht.
1. wenn die CRC der CID in bit0 immer eins ist wie kann dann die CID am Ende 00 sein ?
2. ich habe mal zum spass, zu einer CID das Passwort mal lowercase und mal uppercase geschrieben. Hat beides funktioniert und konnte viceversa auch wieder gelöscht werden also z.B. a0b1c3 gesetzt und mit A0B1C3 gelöscht. Das deckt sich irgendwie nicht mit deiner Aussage.
@Link nur für registrierte und freigeschaltete Mitglieder sichtbar. - hmm...ja...ähh... geht mir genauso! das hat sich mir auch noch nicht erschlossen, warum da nur hin und wieder eine 1 vermerkt ist. laut register-definition ist dieses bit als: "not used and always '1'". gelistet. was die crc7-summe betrifft, meine ich irgendwo in der 'sd-card spezification' mal gelesen zu haben, das man diese explizit mit anfordern muss. erst dann wird sie von der sd-karte auch mit übertragen. aber alles unter vorbehalt und aus meiner erinnerung, ich hab mich da schon ewig nicht mehr mit auseinandergesetzt.
wenn du dich damit hin und wieder beschäftigst, mach das doch mal mit der neuen version 0.8 von 'cmd42'!? würd mich interessieren wie es damit aussieht.
was dein lower/uppercase passwort 0xa0b1c3 angeht, nehme ich jetzt mal an, das du das als hex-passwort übertragen hast?! in diesem fall werden die eingegebenen zeichen natürlich entsprechend überprüft und in einen konformen hex-wert umgewandelt. denn, wie auch immer du das eingibst, ob gross oder klein, als ergebnis willst du hexadezimal den wert '0xa0b1c3' an die sd-karte senden. wenn du das mit einem asc-passwort machst, wird dir das nicht gelingen.
@Link nur für registrierte und freigeschaltete Mitglieder sichtbar. ,
ja, natürlich habe ich das passwort in hex übergeben. Das a0b1c3/A0B1C3 war auch nur als Beispiel für die Groß/Kleinschreibung gedacht.
Und es macht für die Karte keinen Unterschied und damit meine ich nicht, dass beim setzen des Passworts kein Fehler entstanden ist sondern, dass die Karte auch anschließend im Radio akzeptiert wurde.
Wie gesagt, mall mit Großbuchstaben und mal Kleinbuchstaben, beides wurde akzeptiert.
Und das hat mich stutzig gemacht. Deshalb auch die Frage ob die Eingabe evtl. nochmal in Groß oder Kleinbuchstaben umgewandelt wird.
Aber wenn ich deine Antwort richtig interpretiere, dann bedeutet das, dass wenn ich Großbuchstaben im Hex Passwort habe dieses als ungültiges Hexformat angesehen wird und in ein Passwort mit Kleinbuchstaben umgewandelt wird.
Tja und bei der CID, werde ich auch nicht schlauer, wie bekannt soll das rechteste Byte die CRC7 enthalten bit 0 soll immer eine 1 sein.
Soweit die Dokumentation. Ich habe mal einen crc7 über die 15 Bytes laufen lassen bekomme aber etwas völlig anderes heraus.
Wie schon erwähnt, finde ich es seltsam, dass die meisten CID 00 für bit0-15 haben. und wenn ich mit mmc dann mal eine CID schreibe die z.B. fd für bit0-15 hat, wird anschließend bei der CID Abfrage 00 für bit0-15 ausgegeben.
Ich habe leider auch nicht direkt verstanden was mir die SD-Card Doku diesbezüglich sagen will oder anders ausgedrückt ich habe den Eindruck, dass kein normaler crc7 über die 15 Byte gerechnet wird. Mir fehlt leider der Sourcecode um nachzusehen und wenn ich den Sourcecode hätte würde ich es wahrscheinlich auch nicht verstehen da ich ein ganz guter scripter aber kein C Versteher bin. Gerade die Schleifensyntax oder auch Arithmetik sind da komplett anders.
Ich will aber auch nicht zu weit ausholen. Mir ging es eigentlich nur um die generelle Gegenprüfung ob ich mit meiner CRC Prüfung nichts falsch mache. Scheint aber so.
p.s. danke für die neuen Links
Nachtrag: Die v08 sieht genauso aus wie die v06 nur ohne den response status. Die restlichen Werte sehen genauso aus, zumindest ist mir nichts außergewöhnliches aufgefallen.
@Link nur für registrierte und freigeschaltete Mitglieder sichtbar.
ja, natürlich habe ich das passwort in hex übergeben. Das a0b1c3/A0B1C3 war auch nur als Beispiel für die Groß/Kleinschreibung gedacht.
Und es macht für die Karte keinen Unterschied und damit meine ich nicht, dass beim setzen des Passworts kein Fehler entstanden ist sondern, dass die Karte auch anschließend im Radio akzeptiert wurde.
Wie gesagt, mall mit Großbuchstaben und mal Kleinbuchstaben, beides wurde akzeptiert.
Und das hat mich stutzig gemacht. Deshalb auch die Frage ob die Eingabe evtl. nochmal in Groß oder Kleinbuchstaben umgewandelt wird.
Aber wenn ich deine Antwort richtig interpretiere, dann bedeutet das, dass wenn ich Großbuchstaben im Hex Passwort habe dieses als ungültiges Hexformat angesehen wird und in ein Passwort mit Kleinbuchstaben umgewandelt wird.
was das hex-passwort angeht, muss bei beiden arten gewandelt werden, sowohl bei der gross als auch bei der kleinschreibung. das, was du auf dem bildschirm (im terminal) siehst, ist nicht der echte hex-wert, den 'cmd42' an die sd-karte sendet. um bei deinem beispiel 'a0b1c3' zu bleiben, wenn du diese zeichenkette im terminal eingibst, besteht diese kette aus 6 zeichen "a0b1c3". genau genommen sind das aber die ascii-(hex)werte: 0x61 0x30 0x62 0x31 0x63 0x33. 'cmd42' fasst nun diese 6 zeichen zu zweier-gruppen zusammen und konvertiert jeweils 2 zeichen zu einem byte mit dem eigentlichen hexadezimal-wert. aus "0x6130 6231 6333' wird am ende $a0 $b1 $c3. jedes dieser 3 bytes ist als charakter auf dem bildschirm nicht darstellbar, deswegen spricht man hier im allgemeinen von hex-werten. $a0 kenne ich z. bsp. noch als sog. 'alternate space' heute allgemein als 'non-break space' bezeichnet, mit dem man das word-wrapping für eine reihe von wörtern in texten verhindern kann.
Code:
hier mal eine ausgabe der ascii-tabelle. gleiches kannst du auch im
terminal von 'Simply@Clever' machen. wenn ich mich recht entsinne,
ist der befehl 'ascii' als standard-befehl im system implementiert.
$ ascii
Usage: ascii [-adxohv] [-t] [char-alias...]
-t = one-line output -a = vertical format
-d = Decimal table -o = octal table -x = hex table -b binary table
-h = This help screen -v = version information
Prints all aliases of an ASCII character. Args may be chars, C \-escapes,
English names, ^-escapes, ASCII mnemonics, or numerics in decimal/octal/hex.
Dec Hex Dec Hex Dec Hex Dec Hex Dec Hex Dec Hex Dec Hex Dec Hex
0 00 NUL 16 10 DLE 32 20 48 30 0 64 40 @ 80 50 P 96 60 ` 112 70 p
1 01 SOH 17 11 DC1 33 21 ! 49 31 1 65 41 A 81 51 Q 97 61 a 113 71 q
2 02 STX 18 12 DC2 34 22 " 50 32 2 66 42 B 82 52 R 98 62 b 114 72 r
3 03 ETX 19 13 DC3 35 23 # 51 33 3 67 43 C 83 53 S 99 63 c 115 73 s
4 04 EOT 20 14 DC4 36 24 $ 52 34 4 68 44 D 84 54 T 100 64 d 116 74 t
5 05 ENQ 21 15 NAK 37 25 % 53 35 5 69 45 E 85 55 U 101 65 e 117 75 u
6 06 ACK 22 16 SYN 38 26 & 54 36 6 70 46 F 86 56 V 102 66 f 118 76 v
7 07 BEL 23 17 ETB 39 27 ' 55 37 7 71 47 G 87 57 W 103 67 g 119 77 w
8 08 BS 24 18 CAN 40 28 ( 56 38 8 72 48 H 88 58 X 104 68 h 120 78 x
9 09 HT 25 19 EM 41 29 ) 57 39 9 73 49 I 89 59 Y 105 69 i 121 79 y
10 0A LF 26 1A SUB 42 2A * 58 3A : 74 4A J 90 5A Z 106 6A j 122 7A z
11 0B VT 27 1B ESC 43 2B + 59 3B ; 75 4B K 91 5B [ 107 6B k 123 7B {
12 0C FF 28 1C FS 44 2C , 60 3C < 76 4C L 92 5C \ 108 6C l 124 7C |
13 0D CR 29 1D GS 45 2D - 61 3D = 77 4D M 93 5D ] 109 6D m 125 7D }
14 0E SO 30 1E RS 46 2E . 62 3E > 78 4E N 94 5E ^ 110 6E n 126 7E ~
15 0F SI 31 1F US 47 2F / 63 3F ? 79 4F O 95 5F _ 111 6F o 127 7F DEL
Code:
oder, wenn du sehen willst aus welchen hex-werten die
CID 1b534d454231515430ba2f5f9f0114fd besteht?!
probiere folgendes:
echo 1b534d454231515430ba2f5f9f0114fd | xxd [ENTER]
Zitat von manyone
@Link nur für registrierte und freigeschaltete Mitglieder sichtbar.
Tja und bei der CID, werde ich auch nicht schlauer, wie bekannt soll das rechteste Byte die CRC7 enthalten bit 0 soll immer eine 1 sein.
Soweit die Dokumentation. Ich habe mal einen crc7 über die 15 Bytes laufen lassen bekomme aber etwas völlig anderes heraus...
wenn du von der obrigen CID 1b534d454231515430ba2f5f9f0114fd sprichst, scheint das aber zu passen?! schiebe das letzte byte $fd %11111101 um ein bit nach rechts, damit das sog. 'unused bit' rausfliegt. dann wird daraus $7e %01111110. wenn ich für den verbliebenen rest 1b534d454231515430ba2f5f9f0114 in einem online crc-calculator die crc7-summe berechnen lasse, kommt da ebenfalls $7e raus, scheint also zu stimmen?!
wenn du eine neue CID auf die sd-karte schreibst, würde ich dafür auch grundsätzlich 'evoplus_cid' statt 'mmc32/mmc64' empfehlen!!! der 'mmc'-befehl ist ein bischen dahingepfuscht und nicht so ganz das gelbe vom ei. 'evoplus_cid' ist da deutlich strukturierter und bietet die möglichkeit beim schreiben der CID auch gleich die crc7-summe zu berechnen. du musst dafür bei einer 32-zeichen langen CID nur die letzten beiden bytes weglassen. also nur den verbliebenen rest, von dem ich oben geschrieben hab, eingeben. näheres findest du dazu, wenn du 'evoplus_cid' ohne weitere argumente aufrufst.
bei evoplus_cid versuche ich gerade zu verstehen wie die CRC7 gemacht wird.
Ist mir momentan noch ein Mathematisches Rätsel, da es meinem Verständnis nach völlig anders funktioniert wie ich mir die Erzeugung eines CRC7 angesehen habe (shift des polynom von links nach rechts der Message).
Ich werde mal versuchen ob ich das mit evoplus_cid hinbekomme (weiss nicht wie alt die Version ist, die ich habe) und ob mir die Prüfsumme dann angezeigt wird.
@Link nur für registrierte und freigeschaltete Mitglieder sichtbar. - falls es dich interessiert, hier ein paar zeilen in 'C' zur crc7-summe. die crc7-routine stammt von 'evoplus_cid', den rest habe ich drumherum gebastelt und an vielen stellen kommentiert. 'crc7' erwartet als eingabe eine 30-stellige CID und berechnet daraus die reguläre checksumme und die um 1 bit nach links geschobene summe + stoppbit (dieses 'unused bit' am ende der CID).
der sourcecode müsste sich auch unter verwendung von 'simply@clever' problemlos compilieren lassen. den ganzen text aus dem codefeld mittels copy&paste in ein neues file 'crc7.c' kopieren. in dem ordner wo 'crc7.c' abgelegt wurde ein terminal öffnen und mit dem 'gcc' kompilieren. danach die properties der kompilierten datei 'crc7' öffnen und unter 'permissons' den haken für 'executable' setzen. gleiches lässt sich auch mit 'chmod' bewerkstelligen (siehe folgende zeilen).
gcc -o crc7 crc7.c [ENTER]
chmod 777 crc7 [ENTER]
Code:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define CID_SIZE 16
//******************************************************************************
unsigned char crc7(const unsigned char data[], int len) {
int count;
unsigned char crc = 0;
for (count = 0; count <= len; count++) {
unsigned char dat;
unsigned char bits;
if (count == len) {
dat = 0;
bits = 7;
} else {
dat = data[count];
bits = 8;
}
for (; bits > 0; bits--) {
crc = (crc << 1) + ( (dat & 0x80) ? 1 : 0 );
if (crc & 0x80) crc ^= 0x09;
dat <<= 1;
}
crc &= 0x7f;
}
return ((crc << 1) + 1);
}
//******************************************************************************
void main(int argc, const char **argv) {
unsigned char cid[CID_SIZE] = {0};
// crc7 needs only 1 arg, print 'usage' otherwise ******************************
if (argc != 2) {
printf("\nUsage: %s <CID>\n\n",argv[0]);
printf("\tcalculates the crc7 checksum for a given CID.\n");
printf("\tCID must be in hex (without 0x prefix) and 30 chars. in length.\n\n");
printf("\texample: 1b534d4543344d57308bd55d2c0112\n\n");
return;
}
// check CID length - should be 30 chars. long ********************************
int buf_len=strlen(argv[1]);
if (buf_len != 30) {
printf("INVALID CID SIZE (length should be 30 char.)\n");
exit(1);
}
// check arg[1] for suitable chars. ********************************************
int hex_len = strspn(argv[1],"0123456789abcdefABCDEF");
if (buf_len != hex_len) {
printf("INVALID PARAMETER at POS:%d (char. should be a hex-value!)\n",hex_len+1);
exit(1);
}
// convert CID ascii2hex *******************************************************
for (int i = 0; i < (buf_len/2); i++){sscanf(&argv[1][i*2], "%2hhx", &cid[i]);}
// calculate crc7 checksum + left shift by 1 bit + stoppbit(1) *****************
cid[15] = crc7(cid, 15); // cal. crcsum + left shift and stoppbit
int checksum = (cid[15] >> 1); // get back the regular crc7 sum
printf("\n CID = %s%02x\nCRC7 = $%02x left shift + 1 stoppbit= $%02x\n\n",argv[1],cid[15],checksum,cid[15]);
exit;
}
// EOF *************************************************************************
falls das mit dem kompilieren nicht gelingt, hier die ausführbare datei im base64 format. ähnlich wie oben, den text im codefeld mittels copy&paste in eine neue datei 'crc7.base64' kopieren und mit 'base64' in eine binär-datei zurückwandeln.
nachtrag: beides funktioniert auch unter live-bedingungen mit 'Simply@Clever' der compiler 'gcc' und 'base64' sind integriert. bei dem 'ascii'-befehl hab ich mich geirrt, den muss ich irgendwann später mal nachinstalliert haben. der existiert leider nicht. vielleicht im nächsten update?!
da hat sich aber einer mal Mühe gemacht.
Danke jori, wäre aber nicht notwendig gewesen, den sourcecode von evoplus_cid habe ich ja.
Die Funktionsweise des crc7 Teils habe ich mittlerweile auch verstanden. Da ich bis eben gearbeitet habe, weiß ich noch nicht ob ich da heute noch einen Testlauf mit evolus_cid machen werde.
Karte schreiben vielleicht aber im Auto ausprobieren wohl eher morgen.
Nachtrag:
habe mit evoplus_cid die CID geschrieben, macht aber keinen Unterschied zu MMC.
Die CID wird beim auslesen (egal ob sdinfo oder mit cat .../cid) immer ohne die Prüfsumme ausgegeben.
Deshalb stellt sich mir die Frage ob die Prüfsumme überhaupt auf die Karte geschrieben wird oder nur zur Prüfung der Kommunikation dient und beim schreiben auf die Karte 00 eingesetzt wird.
Aber das macht für mich auch nicht wirklich Sinn, denn beim Auslesen der CID muss doch eigentlich auch eine Prüfsumme übergeben werden, oder ?
Du müsstest das doch wissen jori, bekommst du bei sdinfo, wenn du die Kartendaten abrufst bei der CID eine Prüfsumme ? ich schätze nein, sonst könntest du Sie ja ausgeben.
@Link nur für registrierte und freigeschaltete Mitglieder sichtbar. - bitte gern! war nur so 'just for fun'!!! können sich ja auch andere runterkopieren und zusammen frickeln. vielleicht interessiert es ja den einen oder anderen. wenn du da irgendwann mal wieder rangehst und spass daran hast?! vielleicht könntest du in diesem zuge ja auch mal ein paar der CID/passwort-kombinationen aus meinem nachbar-thema: (SD-Info) ein Tool zum Karten-Update RNS310/RNS315 (AMUNDSEN+) ausprobieren und mit dem navi testen ob es eine sd-karte mit einer dieser kombinationen annehmen würde. wenn ich mit mein notebook unlocken könnte, hätte ich das schon längst mal ausprobiert.
ein paar Kombinationen habe ich schon bei meiner Suche nach einem Passwortalgorythmus ausprobiert, jetzt nicht aus deinem Thread sondern im Internet in anderen Foren gesammelt, wo das Passwort von verschiedenen Usern, die es errechnen oder anders herausbekommen konnten, bereitgestellt wurde. Da das ganze recht zeitaufwendig ist (10 - 15 Min. pro Versuch) habe ich nur die interessantesten CID ausprobiert.
Alle folgenden Kombinationen sind von meinem Amundsen+/RNS315 akzeptiert worden.
CID 1b534d454231515430cb6b5f66011507
PWD 5da3e1603db22532f0a459b2974254dc
@Link nur für registrierte und freigeschaltete Mitglieder sichtbar. - na, bitte! schönen dank für die info! dann ist das ja wohl auch bewiesen: CID egal! hauptsache das PW passt dazu! ich war mir da nicht ganz so sicher, weil ich es selbst bis dato leider nicht testen konnte.
dem 'crc7'-befehl habe ich aus spass am frickeln, gestern noch eine 'verbose'-option verpasst. an der ausgabe die daraus resultiert lässt sich schön erkennen, wie die einzelnen bits pro byte geshiftet werden. das kleine projekt werde ich demnächst als zusatz mit ins thema von'Simply@Clever' nehmen.
mfg jori...
Code:
$ ./crc7 1b534d3030303030106a5e065400fb verbose
dat = 1b 00011011
crc = 00 00000000 dat = 36 00110110
crc = 00 00000000 dat = 6c 01101100
crc = 00 00000000 dat = d8 11011000
crc = 01 00000001 dat = b0 10110000
crc = 03 00000011 dat = 60 01100000
crc = 06 00000110 dat = c0 11000000
crc = 0d 00001101 dat = 80 10000000
crc = 1b 00011011 dat = 00 00000000
dat = 53 01010011
crc = 36 00110110 dat = a6 10100110
crc = 6d 01101101 dat = 4c 01001100
crc = d3 11010011 dat = 98 10011000
crc = ae 10101110 dat = 30 00110000
crc = 5c 01011100 dat = 60 01100000
crc = b1 10110001 dat = c0 11000000
crc = 63 01100011 dat = 80 10000000
crc = ce 11001110 dat = 00 00000000
dat = 4d 01001101
crc = 95 10010101 dat = 9a 10011010
crc = 2b 00101011 dat = 34 00110100
crc = 56 01010110 dat = 68 01101000
crc = a5 10100101 dat = d0 11010000
crc = 4b 01001011 dat = a0 10100000
crc = 9e 10011110 dat = 40 01000000
crc = 3c 00111100 dat = 80 10000000
crc = 79 01111001 dat = 00 00000000
dat = 30 00110000
crc = fb 11111011 dat = 60 01100000
crc = ff 11111111 dat = c0 11000000
crc = f6 11110110 dat = 80 10000000
crc = e4 11100100 dat = 00 00000000
crc = c1 11000001 dat = 00 00000000
crc = 8b 10001011 dat = 00 00000000
crc = 16 00010110 dat = 00 00000000
crc = 2c 00101100 dat = 00 00000000
dat = 30 00110000
crc = 58 01011000 dat = 60 01100000
crc = b9 10111001 dat = c0 11000000
crc = 73 01110011 dat = 80 10000000
crc = ee 11101110 dat = 00 00000000
crc = d5 11010101 dat = 00 00000000
crc = a3 10100011 dat = 00 00000000
crc = 46 01000110 dat = 00 00000000
crc = 85 10000101 dat = 00 00000000
dat = 30 00110000
crc = 0a 00001010 dat = 60 01100000
crc = 14 00010100 dat = c0 11000000
crc = 29 00101001 dat = 80 10000000
crc = 53 01010011 dat = 00 00000000
crc = af 10101111 dat = 00 00000000
crc = 5e 01011110 dat = 00 00000000
crc = b5 10110101 dat = 00 00000000
crc = 6a 01101010 dat = 00 00000000
dat = 30 00110000
crc = dd 11011101 dat = 60 01100000
crc = b3 10110011 dat = c0 11000000
crc = 67 01100111 dat = 80 10000000
crc = c6 11000110 dat = 00 00000000
crc = 85 10000101 dat = 00 00000000
crc = 0a 00001010 dat = 00 00000000
crc = 14 00010100 dat = 00 00000000
crc = 28 00101000 dat = 00 00000000
dat = 30 00110000
crc = 50 01010000 dat = 60 01100000
crc = a9 10101001 dat = c0 11000000
crc = 53 01010011 dat = 80 10000000
crc = ae 10101110 dat = 00 00000000
crc = 5c 01011100 dat = 00 00000000
crc = b1 10110001 dat = 00 00000000
crc = 62 01100010 dat = 00 00000000
crc = cd 11001101 dat = 00 00000000
dat = 10 00010000
crc = 93 10010011 dat = 20 00100000
crc = 26 00100110 dat = 40 01000000
crc = 4c 01001100 dat = 80 10000000
crc = 90 10010000 dat = 00 00000000
crc = 20 00100000 dat = 00 00000000
crc = 40 01000000 dat = 00 00000000
crc = 89 10001001 dat = 00 00000000
crc = 12 00010010 dat = 00 00000000
dat = 6a 01101010
crc = 24 00100100 dat = d4 11010100
crc = 49 01001001 dat = a8 10101000
crc = 9a 10011010 dat = 50 01010000
crc = 34 00110100 dat = a0 10100000
crc = 69 01101001 dat = 40 01000000
crc = db 11011011 dat = 80 10000000
crc = be 10111110 dat = 00 00000000
crc = 7c 01111100 dat = 00 00000000
dat = 5e 01011110
crc = f1 11110001 dat = bc 10111100
crc = ea 11101010 dat = 78 01111000
crc = dd 11011101 dat = f0 11110000
crc = b2 10110010 dat = e0 11100000
crc = 65 01100101 dat = c0 11000000
crc = c2 11000010 dat = 80 10000000
crc = 8c 10001100 dat = 00 00000000
crc = 18 00011000 dat = 00 00000000
dat = 06 00000110
crc = 30 00110000 dat = 0c 00001100
crc = 60 01100000 dat = 18 00011000
crc = c9 11001001 dat = 30 00110000
crc = 9b 10011011 dat = 60 01100000
crc = 36 00110110 dat = c0 11000000
crc = 6d 01101101 dat = 80 10000000
crc = d2 11010010 dat = 00 00000000
crc = ad 10101101 dat = 00 00000000
dat = 54 01010100
crc = 5a 01011010 dat = a8 10101000
crc = bc 10111100 dat = 50 01010000
crc = 78 01111000 dat = a0 10100000
crc = f8 11111000 dat = 40 01000000
crc = f9 11111001 dat = 80 10000000
crc = fa 11111010 dat = 00 00000000
crc = fd 11111101 dat = 00 00000000
crc = f3 11110011 dat = 00 00000000
dat = 00 00000000
crc = ef 11101111 dat = 00 00000000
crc = d7 11010111 dat = 00 00000000
crc = a7 10100111 dat = 00 00000000
crc = 4e 01001110 dat = 00 00000000
crc = 95 10010101 dat = 00 00000000
crc = 2a 00101010 dat = 00 00000000
crc = 54 01010100 dat = 00 00000000
crc = a1 10100001 dat = 00 00000000
dat = fb 11111011
crc = 43 01000011 dat = f6 11110110
crc = 8e 10001110 dat = ec 11101100
crc = 1d 00011101 dat = d8 11011000
crc = 3b 00111011 dat = b0 10110000
crc = 77 01110111 dat = 60 01100000
crc = e7 11100111 dat = c0 11000000
crc = c6 11000110 dat = 80 10000000
crc = 84 10000100 dat = 00 00000000
dat = 00 00000000
crc = 08 00001000 dat = 00 00000000
crc = 10 00010000 dat = 00 00000000
crc = 20 00100000 dat = 00 00000000
crc = 40 01000000 dat = 00 00000000
crc = 89 10001001 dat = 00 00000000
crc = 12 00010010 dat = 00 00000000
crc = 24 00100100 dat = 00 00000000
CID = 1b534d3030303030106a5e065400fb49
CRC7 = $24 left shift + 1 stoppbit= $49
Hallo, kann mir einer helfen? Ich habe einen Rechner der mit der mmc64 Cid ändern und auch die Karten entsperren kann
Ich hab jetzt das ganze mit der cmd 42 versucht und dies funktioniert einfach nicht
Datei oder Verzeichnis nicht gefunden
Ordner mit der Datei auf Desktop kopiert, dann geöffnet, Im Terminal geöffnet, sudo -s Enter und Befehl laut Anleitung (./cmd42 paswort hex s /dev/mmcblk0
Danke
Hi, meines Wissens ist cmd42 nicht Bestandteil einer normalen Ubuntu Version.
In der modifizierten Variante Simply Clever vom User @Link nur für registrierte und freigeschaltete Mitglieder sichtbar. hier aus dem Forum ist das mit dabei.
Gruß
Frabusoft
Lesezeichen