mirror of
https://github.com/RfidResearchGroup/proxmark3.git
synced 2024-09-20 15:26:13 +08:00
FIX: em410xdemod empty tag id
Code cleanup
This commit is contained in:
Chris
parent
761e0cd0f9
commit
fb49ca9735
447
client/cmddata.c
447
client/cmddata.c
|
|
@ -237,14 +237,14 @@ int usage_data_fsktonrz() {
|
|||
|
||||
//set the demod buffer with given array of binary (one bit per byte)
|
||||
//by marshmellow
|
||||
void setDemodBuf(uint8_t *buf, size_t size, size_t startIdx) {
|
||||
void setDemodBuf(uint8_t *buf, size_t size, size_t start_idx) {
|
||||
if (buf == NULL) return;
|
||||
|
||||
if ( size > MAX_DEMOD_BUF_LEN - startIdx)
|
||||
size = MAX_DEMOD_BUF_LEN - startIdx;
|
||||
if ( size > MAX_DEMOD_BUF_LEN - start_idx)
|
||||
size = MAX_DEMOD_BUF_LEN - start_idx;
|
||||
|
||||
for (size_t i = 0; i < size; i++)
|
||||
DemodBuffer[i] = buf[startIdx++];
|
||||
DemodBuffer[i] = buf[start_idx++];
|
||||
|
||||
DemodBufferLen = size;
|
||||
}
|
||||
|
|
@ -346,10 +346,11 @@ void save_restoreDB(uint8_t saveOpt) {
|
|||
|
||||
memcpy(SavedDB, DemodBuffer, sizeof(DemodBuffer));
|
||||
SavedDBlen = DemodBufferLen;
|
||||
DB_Saved=true;
|
||||
DB_Saved = true;
|
||||
savedDemodStartIdx = g_DemodStartIdx;
|
||||
savedDemodClock = g_DemodClock;
|
||||
} else if (DB_Saved) { //restore
|
||||
|
||||
memcpy(DemodBuffer, SavedDB, sizeof(DemodBuffer));
|
||||
DemodBufferLen = SavedDBlen;
|
||||
g_DemodClock = savedDemodClock;
|
||||
|
|
@ -422,10 +423,12 @@ int CmdPrintDemodBuff(const char *Cmd) {
|
|||
char *buf = (char *) (DemodBuffer + offset);
|
||||
numBits = (numBits > sizeof(hex)) ? sizeof(hex) : numBits;
|
||||
numBits = binarraytohex(hex, buf, numBits);
|
||||
if (numBits==0) return 0;
|
||||
PrintAndLogEx(NORMAL, "DemodBuffer: %s",hex);
|
||||
if (numBits == 0) {
|
||||
return 0;
|
||||
}
|
||||
PrintAndLogEx(NORMAL, "DemodBuffer: %s", hex);
|
||||
} else {
|
||||
PrintAndLogEx(NORMAL, "DemodBuffer:\n%s", sprint_bin_break(DemodBuffer+offset,numBits,16));
|
||||
PrintAndLogEx(NORMAL, "DemodBuffer:\n%s", sprint_bin_break(DemodBuffer+offset, numBits, 16));
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -544,14 +547,14 @@ int ASKDemod(const char *Cmd, bool verbose, bool emSearch, uint8_t askType) {
|
|||
//prints binary found and saves in graphbuffer for further commands
|
||||
int Cmdaskmandemod(const char *Cmd)
|
||||
{
|
||||
char cmdp = param_getchar(Cmd, 0);
|
||||
if (strlen(Cmd) > 45 || cmdp == 'h' || cmdp == 'H') return usage_data_rawdemod_am();
|
||||
char cmdp = tolower(param_getchar(Cmd, 0));
|
||||
if (strlen(Cmd) > 45 || cmdp == 'h') return usage_data_rawdemod_am();
|
||||
|
||||
bool st = true;
|
||||
if (Cmd[0]=='s')
|
||||
if (Cmd[0] == 's')
|
||||
return ASKDemod_ext(Cmd++, true, true, 1, &st);
|
||||
else if (Cmd[1] == 's')
|
||||
return ASKDemod_ext(Cmd+=2, true, true, 1, &st);
|
||||
return ASKDemod_ext(Cmd += 2, true, true, 1, &st);
|
||||
|
||||
return ASKDemod(Cmd, true, true, 1);
|
||||
}
|
||||
|
|
@ -559,27 +562,26 @@ int Cmdaskmandemod(const char *Cmd)
|
|||
//by marshmellow
|
||||
//manchester decode
|
||||
//stricktly take 10 and 01 and convert to 0 and 1
|
||||
int Cmdmandecoderaw(const char *Cmd)
|
||||
{
|
||||
int i = 0;
|
||||
int errCnt = 0;
|
||||
int Cmdmandecoderaw(const char *Cmd) {
|
||||
size_t size = 0;
|
||||
int invert = 0;
|
||||
int maxErr = 20;
|
||||
char cmdp = param_getchar(Cmd, 0);
|
||||
if (strlen(Cmd) > 5 || cmdp == 'h' || cmdp == 'H') return usage_data_manrawdecode();
|
||||
|
||||
if (DemodBufferLen==0) return 0;
|
||||
uint8_t BitStream[MAX_DEMOD_BUF_LEN]={0};
|
||||
int high = 0, low = 0;
|
||||
int i = 0, errCnt = 0, invert = 0, maxErr = 20;
|
||||
char cmdp = tolower(param_getchar(Cmd, 0));
|
||||
if (strlen(Cmd) > 5 || cmdp == 'h') return usage_data_manrawdecode();
|
||||
|
||||
if (DemodBufferLen == 0) return 0;
|
||||
|
||||
uint8_t bits[MAX_DEMOD_BUF_LEN] = {0};
|
||||
|
||||
for (; i < DemodBufferLen; ++i){
|
||||
if (DemodBuffer[i] > high)
|
||||
high=DemodBuffer[i];
|
||||
high = DemodBuffer[i];
|
||||
else if(DemodBuffer[i] < low)
|
||||
low=DemodBuffer[i];
|
||||
BitStream[i] = DemodBuffer[i];
|
||||
low = DemodBuffer[i];
|
||||
bits[i] = DemodBuffer[i];
|
||||
}
|
||||
if (high>7 || low <0 ){
|
||||
|
||||
if (high > 7 || low < 0 ){
|
||||
PrintAndLogEx(WARNING, "Error: please raw demod the wave first then manchester raw decode");
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -587,20 +589,22 @@ int Cmdmandecoderaw(const char *Cmd)
|
|||
sscanf(Cmd, "%i %i", &invert, &maxErr);
|
||||
size = i;
|
||||
uint8_t alignPos = 0;
|
||||
errCnt = manrawdecode(BitStream, &size, invert, &alignPos);
|
||||
errCnt = manrawdecode(bits, &size, invert, &alignPos);
|
||||
if (errCnt >= maxErr){
|
||||
PrintAndLogEx(WARNING, "Too many errors: %d",errCnt);
|
||||
return 0;
|
||||
}
|
||||
|
||||
PrintAndLogEx(NORMAL, "Manchester Decoded - # errors:%d - data:",errCnt);
|
||||
PrintAndLogEx(NORMAL, "%s", sprint_bin_break(BitStream, size, 16));
|
||||
PrintAndLogEx(NORMAL, "%s", sprint_bin_break(bits, size, 16));
|
||||
|
||||
if (errCnt == 0){
|
||||
uint64_t id = 0;
|
||||
uint32_t hi = 0;
|
||||
size_t idx=0;
|
||||
if (Em410xDecode(BitStream, &size, &idx, &hi, &id)){
|
||||
size_t idx = 0;
|
||||
if (Em410xDecode(bits, &size, &idx, &hi, &id) == 1){
|
||||
//need to adjust to set bitstream back to manchester encoded data
|
||||
//setDemodBuf(BitStream, size, idx);
|
||||
//setDemodBuf(bits, size, idx);
|
||||
printEM410x(hi, id);
|
||||
}
|
||||
}
|
||||
|
|
@ -613,22 +617,23 @@ int Cmdmandecoderaw(const char *Cmd)
|
|||
//takes 2 arguments "offset" default = 0 if 1 it will shift the decode by one bit
|
||||
// and "invert" default = 0 if 1 it will invert output
|
||||
// the argument offset allows us to manually shift if the output is incorrect - [EDIT: now auto detects]
|
||||
int CmdBiphaseDecodeRaw(const char *Cmd)
|
||||
{
|
||||
size_t size=0;
|
||||
int offset=0, invert=0, maxErr=20, errCnt=0;
|
||||
char cmdp = param_getchar(Cmd, 0);
|
||||
if (strlen(Cmd) > 3 || cmdp == 'h' || cmdp == 'H') return usage_data_biphaserawdecode();
|
||||
int CmdBiphaseDecodeRaw(const char *Cmd) {
|
||||
size_t size = 0;
|
||||
int offset = 0, invert = 0, maxErr = 20, errCnt = 0;
|
||||
char cmdp = tolower(param_getchar(Cmd, 0));
|
||||
if (strlen(Cmd) > 3 || cmdp == 'h') return usage_data_biphaserawdecode();
|
||||
|
||||
sscanf(Cmd, "%i %i %i", &offset, &invert, &maxErr);
|
||||
if (DemodBufferLen==0){
|
||||
if (DemodBufferLen == 0){
|
||||
PrintAndLogEx(NORMAL, "DemodBuffer Empty - run 'data rawdemod ar' first");
|
||||
return 0;
|
||||
}
|
||||
uint8_t BitStream[MAX_DEMOD_BUF_LEN]={0};
|
||||
size = sizeof(BitStream);
|
||||
if ( !getDemodBuf(BitStream, &size) ) return 0;
|
||||
errCnt=BiphaseRawDecode(BitStream, &size, &offset, invert);
|
||||
|
||||
uint8_t bits[MAX_DEMOD_BUF_LEN] = {0};
|
||||
size = sizeof(bits);
|
||||
if ( !getDemodBuf(bits, &size) ) return 0;
|
||||
|
||||
errCnt = BiphaseRawDecode(bits, &size, &offset, invert);
|
||||
if (errCnt < 0){
|
||||
PrintAndLogEx(WARNING, "Error during decode:%d", errCnt);
|
||||
return 0;
|
||||
|
|
@ -642,10 +647,12 @@ int CmdBiphaseDecodeRaw(const char *Cmd)
|
|||
PrintAndLogEx(WARNING, "# Errors found during Demod (shown as 7 in bit stream): %d",errCnt);
|
||||
|
||||
PrintAndLogEx(NORMAL, "Biphase Decoded using offset: %d - # invert:%d - data:",offset,invert);
|
||||
PrintAndLogEx(NORMAL, "%s", sprint_bin_break(BitStream, size, 16));
|
||||
PrintAndLogEx(NORMAL, "%s", sprint_bin_break(bits, size, 16));
|
||||
|
||||
//remove first bit from raw demod
|
||||
if (offset)
|
||||
setDemodBuf(DemodBuffer,DemodBufferLen-offset, offset); //remove first bit from raw demod
|
||||
setDemodBuf(DemodBuffer,DemodBufferLen-offset, offset);
|
||||
|
||||
setClockGrid(g_DemodClock, g_DemodStartIdx + g_DemodClock*offset/2);
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -1040,21 +1047,19 @@ int FSKrawDemod(const char *Cmd, bool verbose)
|
|||
//fsk raw demod and print binary
|
||||
//takes 4 arguments - Clock, invert, fchigh, fclow
|
||||
//defaults: clock = 50, invert=1, fchigh=10, fclow=8 (RF/10 RF/8 (fsk2a))
|
||||
int CmdFSKrawdemod(const char *Cmd)
|
||||
{
|
||||
char cmdp = param_getchar(Cmd, 0);
|
||||
if (strlen(Cmd) > 20 || cmdp == 'h' || cmdp == 'H') return usage_data_rawdemod_fs();
|
||||
int CmdFSKrawdemod(const char *Cmd) {
|
||||
char cmdp = tolower(param_getchar(Cmd, 0));
|
||||
if (strlen(Cmd) > 20 || cmdp == 'h') return usage_data_rawdemod_fs();
|
||||
|
||||
return FSKrawDemod(Cmd, true);
|
||||
}
|
||||
|
||||
//by marshmellow
|
||||
//attempt to psk1 demod graph buffer
|
||||
int PSKDemod(const char *Cmd, bool verbose)
|
||||
{
|
||||
int PSKDemod(const char *Cmd, bool verbose) {
|
||||
int invert = 0, clk = 0, maxErr = 100;
|
||||
sscanf(Cmd, "%i %i %i", &clk, &invert, &maxErr);
|
||||
if (clk == 1){
|
||||
if (clk == 1) {
|
||||
invert = 1;
|
||||
clk=0;
|
||||
}
|
||||
|
|
@ -1072,14 +1077,14 @@ int PSKDemod(const char *Cmd, bool verbose)
|
|||
if (g_debugMode || verbose) PrintAndLogEx(DEBUG, "DEBUG: (PSKdemod) Too many errors found, clk: %d, invert: %d, numbits: %d, errCnt: %d", clk, invert, BitLen, errCnt);
|
||||
return 0;
|
||||
}
|
||||
if (errCnt<0|| BitLen<16){ //throw away static - allow 1 and -1 (in case of threshold command first)
|
||||
if (errCnt < 0|| BitLen < 16){ //throw away static - allow 1 and -1 (in case of threshold command first)
|
||||
if (g_debugMode || verbose) PrintAndLogEx(DEBUG, "DEBUG: (PSKdemod) no data found, clk: %d, invert: %d, numbits: %d, errCnt: %d", clk, invert, BitLen, errCnt);
|
||||
return 0;
|
||||
}
|
||||
if (verbose || g_debugMode){
|
||||
PrintAndLogEx(DEBUG, "DEBUG: (PSKdemod) Using Clock:%d, invert:%d, Bits Found:%d",clk,invert,BitLen);
|
||||
PrintAndLogEx(DEBUG, "DEBUG: (PSKdemod) Using Clock:%d, invert:%d, Bits Found:%d",clk, invert, BitLen);
|
||||
if (errCnt > 0){
|
||||
PrintAndLogEx(DEBUG, "DEBUG: (PSKdemod) errors during Demoding (shown as 7 in bit stream): %d",errCnt);
|
||||
PrintAndLogEx(DEBUG, "DEBUG: (PSKdemod) errors during Demoding (shown as 7 in bit stream): %d", errCnt);
|
||||
}
|
||||
}
|
||||
//prime demod buffer for output
|
||||
|
|
@ -1103,8 +1108,10 @@ int CmdPSKIdteck(const char *Cmd) {
|
|||
if (idx == -1)
|
||||
PrintAndLogEx(DEBUG, "DEBUG: Error - Idteck: not enough samples");
|
||||
else if (idx == -2)
|
||||
PrintAndLogEx(DEBUG, "DEBUG: Error - Idteck: preamble not found");
|
||||
PrintAndLogEx(DEBUG, "DEBUG: Error - Idteck: just noise");
|
||||
else if (idx == -3)
|
||||
PrintAndLogEx(DEBUG, "DEBUG: Error - Idteck: preamble not found");
|
||||
else if (idx == -4)
|
||||
PrintAndLogEx(DEBUG, "DEBUG: Error - Idteck: size not correct: %d", size);
|
||||
else
|
||||
PrintAndLogEx(DEBUG, "DEBUG: Error - Idteck: idx: %d",idx);
|
||||
|
|
@ -1120,8 +1127,10 @@ int CmdPSKIdteck(const char *Cmd) {
|
|||
if (idx == -1)
|
||||
PrintAndLogEx(DEBUG, "DEBUG: Error - Idteck: not enough samples");
|
||||
else if (idx == -2)
|
||||
PrintAndLogEx(DEBUG, "DEBUG: Error - Idteck: preamble not found");
|
||||
PrintAndLogEx(DEBUG, "DEBUG: Error - Idteck: just noise");
|
||||
else if (idx == -3)
|
||||
PrintAndLogEx(DEBUG, "DEBUG: Error - Idteck: preamble not found");
|
||||
else if (idx == -4)
|
||||
PrintAndLogEx(DEBUG, "DEBUG: Error - Idteck: size not correct: %d", size);
|
||||
else
|
||||
PrintAndLogEx(DEBUG, "DEBUG: Error - Idteck: idx: %d",idx);
|
||||
|
|
@ -1148,41 +1157,42 @@ int CmdPSKIdteck(const char *Cmd) {
|
|||
// takes 3 arguments - clock, invert, maxErr as integers
|
||||
// attempts to demodulate nrz only
|
||||
// prints binary found and saves in demodbuffer for further commands
|
||||
int NRZrawDemod(const char *Cmd, bool verbose)
|
||||
{
|
||||
int invert=0;
|
||||
int clk=0;
|
||||
int maxErr=100;
|
||||
int NRZrawDemod(const char *Cmd, bool verbose) {
|
||||
|
||||
int errCnt = 0, clkStartIdx = 0;
|
||||
int invert = 0, clk = 0, maxErr = 100;
|
||||
sscanf(Cmd, "%i %i %i", &clk, &invert, &maxErr);
|
||||
if (clk==1){
|
||||
invert=1;
|
||||
clk=0;
|
||||
if (clk == 1){
|
||||
invert = 1;
|
||||
clk = 0;
|
||||
}
|
||||
|
||||
if (invert != 0 && invert != 1) {
|
||||
PrintAndLogEx(WARNING, "(NRZrawDemod) Invalid argument: %s", Cmd);
|
||||
return 0;
|
||||
}
|
||||
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
|
||||
size_t BitLen = getFromGraphBuf(BitStream);
|
||||
if (BitLen==0) return 0;
|
||||
int errCnt=0;
|
||||
int clkStartIdx = 0;
|
||||
errCnt = nrzRawDemod(BitStream, &BitLen, &clk, &invert, &clkStartIdx);
|
||||
|
||||
uint8_t bits[MAX_GRAPH_TRACE_LEN] = {0};
|
||||
size_t BitLen = getFromGraphBuf(bits);
|
||||
|
||||
if (BitLen == 0) return 0;
|
||||
|
||||
errCnt = nrzRawDemod(bits, &BitLen, &clk, &invert, &clkStartIdx);
|
||||
if (errCnt > maxErr){
|
||||
PrintAndLogEx(DEBUG, "DEBUG: (NRZrawDemod) Too many errors found, clk: %d, invert: %d, numbits: %d, errCnt: %d",clk,invert,BitLen,errCnt);
|
||||
return 0;
|
||||
}
|
||||
if (errCnt<0 || BitLen<16){ //throw away static - allow 1 and -1 (in case of threshold command first)
|
||||
PrintAndLogEx(DEBUG, "DEBUG: (NRZrawDemod) no data found, clk: %d, invert: %d, numbits: %d, errCnt: %d",clk,invert,BitLen,errCnt);
|
||||
if (errCnt < 0 || BitLen < 16){ //throw away static - allow 1 and -1 (in case of threshold command first)
|
||||
PrintAndLogEx(DEBUG, "DEBUG: (NRZrawDemod) no data found, clk: %d, invert: %d, numbits: %d, errCnt: %d", clk, invert, BitLen, errCnt);
|
||||
return 0;
|
||||
}
|
||||
if (verbose || g_debugMode) PrintAndLogEx(DEBUG, "DEBUG: (NRZrawDemod) Tried NRZ Demod using Clock: %d - invert: %d - Bits Found: %d",clk,invert,BitLen);
|
||||
if (verbose || g_debugMode) PrintAndLogEx(DEBUG, "DEBUG: (NRZrawDemod) Tried NRZ Demod using Clock: %d - invert: %d - Bits Found: %d", clk, invert, BitLen);
|
||||
//prime demod buffer for output
|
||||
setDemodBuf(BitStream,BitLen,0);
|
||||
setDemodBuf(bits, BitLen, 0);
|
||||
setClockGrid(clk, clkStartIdx);
|
||||
|
||||
|
||||
if (errCnt>0 && (verbose || g_debugMode)) PrintAndLogEx(DEBUG, "DEBUG: (NRZrawDemod) Errors during Demoding (shown as 7 in bit stream): %d",errCnt);
|
||||
if (errCnt > 0 && (verbose || g_debugMode)) PrintAndLogEx(DEBUG, "DEBUG: (NRZrawDemod) Errors during Demoding (shown as 7 in bit stream): %d", errCnt);
|
||||
if (verbose || g_debugMode) {
|
||||
PrintAndLogEx(NORMAL, "NRZ demoded bitstream:");
|
||||
// Now output the bitstream to the scrollback by line of 16 bits
|
||||
|
|
@ -1191,10 +1201,9 @@ int NRZrawDemod(const char *Cmd, bool verbose)
|
|||
return 1;
|
||||
}
|
||||
|
||||
int CmdNRZrawDemod(const char *Cmd)
|
||||
{
|
||||
char cmdp = param_getchar(Cmd, 0);
|
||||
if (strlen(Cmd) > 16 || cmdp == 'h' || cmdp == 'H') return usage_data_rawdemod_nr();
|
||||
int CmdNRZrawDemod(const char *Cmd) {
|
||||
char cmdp = tolower(param_getchar(Cmd, 0));
|
||||
if (strlen(Cmd) > 16 || cmdp == 'h') return usage_data_rawdemod_nr();
|
||||
|
||||
return NRZrawDemod(Cmd, true);
|
||||
}
|
||||
|
|
@ -1203,13 +1212,11 @@ int CmdNRZrawDemod(const char *Cmd)
|
|||
// takes 3 arguments - clock, invert, maxErr as integers
|
||||
// attempts to demodulate psk only
|
||||
// prints binary found and saves in demodbuffer for further commands
|
||||
int CmdPSK1rawDemod(const char *Cmd)
|
||||
{
|
||||
int ans;
|
||||
char cmdp = param_getchar(Cmd, 0);
|
||||
if (strlen(Cmd) > 16 || cmdp == 'h' || cmdp == 'H') return usage_data_rawdemod_p1();
|
||||
int CmdPSK1rawDemod(const char *Cmd) {
|
||||
char cmdp = tolower(param_getchar(Cmd, 0));
|
||||
if (strlen(Cmd) > 16 || cmdp == 'h') return usage_data_rawdemod_p1();
|
||||
|
||||
ans = PSKDemod(Cmd, true);
|
||||
int ans = PSKDemod(Cmd, true);
|
||||
//output
|
||||
if (!ans){
|
||||
if (g_debugMode) PrintAndLogEx(WARNING, "Error demoding: %d",ans);
|
||||
|
|
@ -1223,13 +1230,11 @@ int CmdPSK1rawDemod(const char *Cmd)
|
|||
|
||||
// by marshmellow
|
||||
// takes same args as cmdpsk1rawdemod
|
||||
int CmdPSK2rawDemod(const char *Cmd)
|
||||
{
|
||||
int ans = 0;
|
||||
char cmdp = param_getchar(Cmd, 0);
|
||||
if (strlen(Cmd) > 16 || cmdp == 'h' || cmdp == 'H') return usage_data_rawdemod_p2();
|
||||
int CmdPSK2rawDemod(const char *Cmd) {
|
||||
char cmdp = tolower(param_getchar(Cmd, 0));
|
||||
if (strlen(Cmd) > 16 || cmdp == 'h') return usage_data_rawdemod_p2();
|
||||
|
||||
ans = PSKDemod(Cmd, true);
|
||||
int ans = PSKDemod(Cmd, true);
|
||||
if (!ans){
|
||||
if (g_debugMode) PrintAndLogEx(WARNING, "Error demoding: %d",ans);
|
||||
return 0;
|
||||
|
|
@ -1242,31 +1247,22 @@ int CmdPSK2rawDemod(const char *Cmd)
|
|||
}
|
||||
|
||||
// by marshmellow - combines all raw demod functions into one menu command
|
||||
int CmdRawDemod(const char *Cmd)
|
||||
{
|
||||
char cmdp = Cmd[0]; //param_getchar(Cmd, 0);
|
||||
char cmdp2 = Cmd[1];
|
||||
int CmdRawDemod(const char *Cmd) {
|
||||
int ans = 0;
|
||||
|
||||
if (strlen(Cmd) > 35 || cmdp == 'h' || cmdp == 'H' || strlen(Cmd) < 2)
|
||||
if (strlen(Cmd) > 35 || strlen(Cmd) < 2)
|
||||
return usage_data_rawdemod();
|
||||
|
||||
str_lower( (char *)Cmd);
|
||||
|
||||
if (cmdp == 'f' && cmdp2 == 's')
|
||||
ans = CmdFSKrawdemod(Cmd+2);
|
||||
else if(cmdp == 'a' && cmdp2 == 'b')
|
||||
ans = Cmdaskbiphdemod(Cmd+2);
|
||||
else if(cmdp == 'a' && cmdp2 == 'm')
|
||||
ans = Cmdaskmandemod(Cmd+2);
|
||||
else if(cmdp == 'a' && cmdp2 == 'r')
|
||||
ans = Cmdaskrawdemod(Cmd+2);
|
||||
else if(cmdp == 'n' && cmdp2 == 'r')
|
||||
ans = CmdNRZrawDemod(Cmd+2);
|
||||
else if(cmdp == 'p' && cmdp2 == '1')
|
||||
ans = CmdPSK1rawDemod(Cmd+2);
|
||||
else if(cmdp == 'p' && cmdp2 == '2')
|
||||
ans = CmdPSK2rawDemod(Cmd+2);
|
||||
else
|
||||
PrintAndLogEx(WARNING, "Unknown modulation entered - see help ('h') for parameter structure");
|
||||
if (str_startswith(Cmd, "fs")) ans = CmdFSKrawdemod(Cmd+2);
|
||||
else if(str_startswith(Cmd, "ab")) ans = Cmdaskbiphdemod(Cmd+2);
|
||||
else if(str_startswith(Cmd, "am")) ans = Cmdaskmandemod(Cmd+2);
|
||||
else if(str_startswith(Cmd, "ar")) ans = Cmdaskrawdemod(Cmd+2);
|
||||
else if(str_startswith(Cmd, "nr")) ans = CmdNRZrawDemod(Cmd+2);
|
||||
else if(str_startswith(Cmd, "p1")) ans = CmdPSK1rawDemod(Cmd+2);
|
||||
else if(str_startswith(Cmd, "p2")) ans = CmdPSK2rawDemod(Cmd+2);
|
||||
else PrintAndLogEx(WARNING, "Unknown modulation entered - see help ('h') for parameter structure");
|
||||
|
||||
return ans;
|
||||
}
|
||||
|
|
@ -1295,8 +1291,7 @@ void setClockGrid(int clk, int offset) {
|
|||
}
|
||||
}
|
||||
|
||||
int CmdGrid(const char *Cmd)
|
||||
{
|
||||
int CmdGrid(const char *Cmd) {
|
||||
sscanf(Cmd, "%i %i", &PlotGridX, &PlotGridY);
|
||||
PlotGridXdefault = PlotGridX;
|
||||
PlotGridYdefault = PlotGridY;
|
||||
|
|
@ -1310,11 +1305,8 @@ int CmdSetGraphMarkers(const char *Cmd) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
int CmdHexsamples(const char *Cmd)
|
||||
{
|
||||
int i, j;
|
||||
int requested = 0;
|
||||
int offset = 0;
|
||||
int CmdHexsamples(const char *Cmd) {
|
||||
int i, j, requested = 0, offset = 0;
|
||||
char string_buf[25];
|
||||
char* string_ptr = string_buf;
|
||||
uint8_t got[BIGBUF_SIZE];
|
||||
|
|
@ -1322,9 +1314,9 @@ int CmdHexsamples(const char *Cmd)
|
|||
sscanf(Cmd, "%i %i", &requested, &offset);
|
||||
|
||||
/* if no args send something */
|
||||
if (requested == 0) {
|
||||
if (requested == 0)
|
||||
requested = 8;
|
||||
}
|
||||
|
||||
if (offset + requested > sizeof(got)) {
|
||||
PrintAndLogEx(NORMAL, "Tried to read past end of buffer, <bytes> + <offset> > %d", BIGBUF_SIZE);
|
||||
return 0;
|
||||
|
|
@ -1355,17 +1347,14 @@ int CmdHexsamples(const char *Cmd)
|
|||
return 0;
|
||||
}
|
||||
|
||||
int CmdHide(const char *Cmd)
|
||||
{
|
||||
int CmdHide(const char *Cmd) {
|
||||
HideGraphWindow();
|
||||
return 0;
|
||||
}
|
||||
|
||||
//zero mean GraphBuffer
|
||||
int CmdHpf(const char *Cmd)
|
||||
{
|
||||
int i;
|
||||
int accum = 0;
|
||||
int CmdHpf(const char *Cmd) {
|
||||
int i, accum = 0;
|
||||
|
||||
for (i = 10; i < GraphTraceLen; ++i)
|
||||
accum += GraphBuffer[i];
|
||||
|
|
@ -1379,18 +1368,15 @@ int CmdHpf(const char *Cmd)
|
|||
return 0;
|
||||
}
|
||||
|
||||
bool _headBit( BitstreamOut *stream)
|
||||
{
|
||||
bool _headBit( BitstreamOut *stream) {
|
||||
int bytepos = stream->position >> 3; // divide by 8
|
||||
int bitpos = (stream->position++) & 7; // mask out 00000111
|
||||
return (*(stream->buffer + bytepos) >> (7-bitpos)) & 1;
|
||||
}
|
||||
|
||||
uint8_t getByte(uint8_t bits_per_sample, BitstreamOut* b)
|
||||
{
|
||||
int i;
|
||||
uint8_t getByte(uint8_t bits_per_sample, BitstreamOut* b) {
|
||||
uint8_t val = 0;
|
||||
for(i = 0 ; i < bits_per_sample; i++)
|
||||
for(int i = 0 ; i < bits_per_sample; i++)
|
||||
val |= (_headBit(b) << (7-i));
|
||||
|
||||
return val;
|
||||
|
|
@ -1426,7 +1412,9 @@ int getSamples(int n, bool silent) {
|
|||
}
|
||||
|
||||
if (bits_per_sample < 8) {
|
||||
|
||||
if (!silent) PrintAndLogEx(NORMAL, "Unpacking...");
|
||||
|
||||
BitstreamOut bout = { got, bits_per_sample * n, 0};
|
||||
int j =0;
|
||||
for (j = 0; j * bits_per_sample < n * 8 && j < n; j++) {
|
||||
|
|
@ -1434,6 +1422,7 @@ int getSamples(int n, bool silent) {
|
|||
GraphBuffer[j] = ((int) sample )- 128;
|
||||
}
|
||||
GraphTraceLen = j;
|
||||
|
||||
if (!silent) PrintAndLogEx(NORMAL, "Unpacked %d samples" , j );
|
||||
} else {
|
||||
for (int j = 0; j < n; j++) {
|
||||
|
|
@ -1444,9 +1433,7 @@ int getSamples(int n, bool silent) {
|
|||
|
||||
//ICEMAN todo
|
||||
// set signal properties low/high/mean/amplitude and is_noice detection
|
||||
justNoise(got, n);
|
||||
// set signal properties low/high/mean/amplitude and isnoice detection
|
||||
//justNoise_int(GraphBuffer, GraphTraceLen);
|
||||
justNoise(GraphBuffer, GraphTraceLen);
|
||||
|
||||
setClockGrid(0, 0);
|
||||
DemodBufferLen = 0;
|
||||
|
|
@ -1454,8 +1441,7 @@ int getSamples(int n, bool silent) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
int CmdSamples(const char *Cmd)
|
||||
{
|
||||
int CmdSamples(const char *Cmd) {
|
||||
int n = strtol(Cmd, NULL, 0);
|
||||
return getSamples(n, false);
|
||||
}
|
||||
|
|
@ -1550,8 +1536,7 @@ int CmdTuneSamples(const char *Cmd) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
int CmdLoad(const char *Cmd)
|
||||
{
|
||||
int CmdLoad(const char *Cmd) {
|
||||
char filename[FILE_PATH_SIZE] = {0x00};
|
||||
int len = 0;
|
||||
|
||||
|
|
@ -1579,14 +1564,16 @@ int CmdLoad(const char *Cmd)
|
|||
DemodBufferLen = 0;
|
||||
RepaintGraphWindow();
|
||||
|
||||
//ICEMAN todo
|
||||
// set signal properties low/high/mean/amplitude and isnoice detection
|
||||
justNoise_int(GraphBuffer, GraphTraceLen);
|
||||
justNoise(GraphBuffer, GraphTraceLen);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int CmdLtrim(const char *Cmd)
|
||||
{
|
||||
if (GraphTraceLen <= 0) return 0;
|
||||
// trim graph from the end
|
||||
int CmdLtrim(const char *Cmd) {
|
||||
// sanitycheck
|
||||
if (GraphTraceLen <= 0) return 1;
|
||||
|
||||
int ds = atoi(Cmd);
|
||||
for (int i = ds; i < GraphTraceLen; ++i)
|
||||
|
|
@ -1597,10 +1584,14 @@ int CmdLtrim(const char *Cmd)
|
|||
return 0;
|
||||
}
|
||||
|
||||
// trim graph to input argument length
|
||||
int CmdRtrim(const char *Cmd)
|
||||
{
|
||||
// trim graph from the beginning
|
||||
int CmdRtrim(const char *Cmd) {
|
||||
|
||||
int ds = atoi(Cmd);
|
||||
|
||||
// sanitycheck
|
||||
if (GraphTraceLen <= ds) return 1;
|
||||
|
||||
GraphTraceLen = ds;
|
||||
RepaintGraphWindow();
|
||||
return 0;
|
||||
|
|
@ -1611,22 +1602,23 @@ int CmdMtrim(const char *Cmd) {
|
|||
int start = 0, stop = 0;
|
||||
sscanf(Cmd, "%i %i", &start, &stop);
|
||||
|
||||
if (start > GraphTraceLen || stop > GraphTraceLen || start > stop) return 0;
|
||||
start++; //leave start position sample
|
||||
if (start > GraphTraceLen || stop > GraphTraceLen || start > stop) return 1;
|
||||
|
||||
// leave start position sample
|
||||
start++;
|
||||
|
||||
GraphTraceLen = stop - start;
|
||||
for (int i = 0; i < GraphTraceLen; i++) {
|
||||
for (int i = 0; i < GraphTraceLen; i++)
|
||||
GraphBuffer[i] = GraphBuffer[start+i];
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int CmdNorm(const char *Cmd)
|
||||
{
|
||||
int CmdNorm(const char *Cmd) {
|
||||
int i;
|
||||
int max = INT_MIN, min = INT_MAX;
|
||||
|
||||
// Find local min, max
|
||||
for (i = 10; i < GraphTraceLen; ++i) {
|
||||
if (GraphBuffer[i] > max) max = GraphBuffer[i];
|
||||
if (GraphBuffer[i] < min) min = GraphBuffer[i];
|
||||
|
|
@ -1639,19 +1631,22 @@ int CmdNorm(const char *Cmd)
|
|||
}
|
||||
}
|
||||
RepaintGraphWindow();
|
||||
|
||||
//ICEMAN todo
|
||||
// set signal properties low/high/mean/amplitude and isnoice detection
|
||||
justNoise(GraphBuffer, GraphTraceLen);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int CmdPlot(const char *Cmd)
|
||||
{
|
||||
int CmdPlot(const char *Cmd) {
|
||||
ShowGraphWindow();
|
||||
return 0;
|
||||
}
|
||||
|
||||
int CmdSave(const char *Cmd)
|
||||
{
|
||||
char filename[FILE_PATH_SIZE] = {0x00};
|
||||
int CmdSave(const char *Cmd) {
|
||||
|
||||
int len = 0;
|
||||
char filename[FILE_PATH_SIZE] = {0x00};
|
||||
|
||||
len = strlen(Cmd);
|
||||
if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE;
|
||||
|
|
@ -1659,7 +1654,7 @@ int CmdSave(const char *Cmd)
|
|||
|
||||
FILE *f = fopen(filename, "w");
|
||||
if(!f) {
|
||||
PrintAndLogEx(NORMAL, "couldn't open '%s'", filename);
|
||||
PrintAndLogEx(WARNING, "couldn't open '%s'", filename);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -1669,12 +1664,11 @@ int CmdSave(const char *Cmd)
|
|||
if (f)
|
||||
fclose(f);
|
||||
|
||||
PrintAndLogEx(NORMAL, "saved to '%s'", Cmd);
|
||||
PrintAndLogEx(SUCCESS, "saved to '%s'", Cmd);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int CmdScale(const char *Cmd)
|
||||
{
|
||||
int CmdScale(const char *Cmd) {
|
||||
CursorScaleFactor = atoi(Cmd);
|
||||
if (CursorScaleFactor == 0) {
|
||||
PrintAndLogEx(FAILED, "bad, can't have zero scale");
|
||||
|
|
@ -1684,10 +1678,13 @@ int CmdScale(const char *Cmd)
|
|||
return 0;
|
||||
}
|
||||
|
||||
int directionalThreshold(const int* in, int *out, size_t len, int8_t up, int8_t down)
|
||||
{
|
||||
int directionalThreshold(const int* in, int *out, size_t len, int8_t up, int8_t down) {
|
||||
|
||||
int lastValue = in[0];
|
||||
out[0] = 0; // Will be changed at the end, but init 0 as we adjust to last samples value if no threshold kicks in.
|
||||
|
||||
// Will be changed at the end, but init 0 as we adjust to last samples
|
||||
// value if no threshold kicks in.
|
||||
out[0] = 0;
|
||||
|
||||
for (size_t i = 1; i < len; ++i) {
|
||||
// Apply first threshold to samples heading up
|
||||
|
|
@ -1708,30 +1705,28 @@ int directionalThreshold(const int* in, int *out, size_t len, int8_t up, int8_t
|
|||
out[i] = out[i-1];
|
||||
}
|
||||
}
|
||||
out[0] = out[1]; // Align with first edited sample.
|
||||
|
||||
// Align with first edited sample.
|
||||
out[0] = out[1];
|
||||
return 0;
|
||||
}
|
||||
|
||||
int CmdDirectionalThreshold(const char *Cmd)
|
||||
{
|
||||
int8_t upThres = param_get8(Cmd, 0);
|
||||
int8_t downThres = param_get8(Cmd, 1);
|
||||
int CmdDirectionalThreshold(const char *Cmd) {
|
||||
int8_t up = param_get8(Cmd, 0);
|
||||
int8_t down = param_get8(Cmd, 1);
|
||||
|
||||
PrintAndLogEx(NORMAL, "Applying Up Threshold: %d, Down Threshold: %d\n", upThres, downThres);
|
||||
PrintAndLogEx(INFO, "Applying Up Threshold: %d, Down Threshold: %d\n", up, down);
|
||||
|
||||
directionalThreshold(GraphBuffer, GraphBuffer,GraphTraceLen, upThres, downThres);
|
||||
directionalThreshold(GraphBuffer, GraphBuffer,GraphTraceLen, up, down);
|
||||
RepaintGraphWindow();
|
||||
return 0;
|
||||
}
|
||||
|
||||
int CmdZerocrossings(const char *Cmd)
|
||||
{
|
||||
int CmdZerocrossings(const char *Cmd) {
|
||||
// Zero-crossings aren't meaningful unless the signal is zero-mean.
|
||||
CmdHpf("");
|
||||
|
||||
int sign = 1;
|
||||
int zc = 0;
|
||||
int lastZc = 0;
|
||||
int sign = 1, zc = 0, lastZc = 0;
|
||||
|
||||
for (int i = 0; i < GraphTraceLen; ++i) {
|
||||
if (GraphBuffer[i] * sign >= 0) {
|
||||
|
|
@ -1749,6 +1744,10 @@ int CmdZerocrossings(const char *Cmd)
|
|||
}
|
||||
}
|
||||
|
||||
//ICEMAN todo
|
||||
// set signal properties low/high/mean/amplitude and isnoice detection
|
||||
justNoise(GraphBuffer, GraphTraceLen);
|
||||
|
||||
RepaintGraphWindow();
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1758,44 +1757,39 @@ int CmdZerocrossings(const char *Cmd)
|
|||
* @param Cmd
|
||||
* @return
|
||||
*/
|
||||
int Cmdbin2hex(const char *Cmd)
|
||||
{
|
||||
int bg =0, en =0;
|
||||
if(param_getptr(Cmd, &bg, &en, 0))
|
||||
int Cmdbin2hex(const char *Cmd) {
|
||||
int bg = 0, en = 0;
|
||||
if (param_getptr(Cmd, &bg, &en, 0))
|
||||
return usage_data_bin2hex();
|
||||
|
||||
//Number of digits supplied as argument
|
||||
size_t length = en - bg +1;
|
||||
size_t length = en - bg + 1;
|
||||
size_t bytelen = (length+7) / 8;
|
||||
uint8_t* arr = (uint8_t *) malloc(bytelen);
|
||||
memset(arr, 0, bytelen);
|
||||
BitstreamOut bout = { arr, 0, 0 };
|
||||
|
||||
for (; bg <= en ;bg++) {
|
||||
for (; bg <= en; bg++) {
|
||||
char c = Cmd[bg];
|
||||
if( c == '1') pushBit(&bout, 1);
|
||||
else if( c == '0') pushBit(&bout, 0);
|
||||
else PrintAndLogEx(NORMAL, "Ignoring '%c'", c);
|
||||
if( c == '1')
|
||||
pushBit(&bout, 1);
|
||||
else if( c == '0')
|
||||
pushBit(&bout, 0);
|
||||
else
|
||||
PrintAndLogEx(NORMAL, "Ignoring '%c'", c);
|
||||
}
|
||||
|
||||
if (bout.numbits % 8 != 0)
|
||||
PrintAndLogEx(NORMAL, "[padded with %d zeroes]\n", 8-(bout.numbits % 8));
|
||||
PrintAndLogEx(NORMAL, "[padded with %d zeroes]", 8 - (bout.numbits % 8));
|
||||
|
||||
//Uses printf instead of PrintAndLog since the latter
|
||||
// adds linebreaks to each printout - this way was more convenient since we don't have to
|
||||
// allocate a string and write to that first...
|
||||
for(size_t x = 0; x < bytelen ; x++)
|
||||
PrintAndLogEx(NORMAL, "%02X", arr[x]);
|
||||
|
||||
PrintAndLogEx(NORMAL, "\n");
|
||||
PrintAndLogEx(NORMAL, "%s", sprint_hex(arr, bytelen));
|
||||
free(arr);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int Cmdhex2bin(const char *Cmd)
|
||||
{
|
||||
int bg =0, en =0;
|
||||
if(param_getptr(Cmd, &bg, &en, 0)) return usage_data_hex2bin();
|
||||
int Cmdhex2bin(const char *Cmd) {
|
||||
int bg = 0, en = 0;
|
||||
if (param_getptr(Cmd, &bg, &en, 0)) return usage_data_hex2bin();
|
||||
|
||||
while (bg <= en ) {
|
||||
char x = Cmd[bg++];
|
||||
|
|
@ -1813,12 +1807,10 @@ int Cmdhex2bin(const char *Cmd)
|
|||
//Uses printf instead of PrintAndLog since the latter
|
||||
// adds linebreaks to each printout - this way was more convenient since we don't have to
|
||||
// allocate a string and write to that first...
|
||||
|
||||
for(int i= 0 ; i < 4 ; ++i)
|
||||
for(int i = 0 ; i < 4 ; ++i)
|
||||
PrintAndLogEx(NORMAL, "%d",(x >> (3 - i)) & 1);
|
||||
}
|
||||
PrintAndLogEx(NORMAL, "\n");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -1845,7 +1837,7 @@ void GetHiLoTone(int *LowTone, int *HighTone, int clk, int LowToneFC, int HighTo
|
|||
int Right_Modifier = (clk % LowToneFC) / 2;
|
||||
//int HighToneMod = clk mod HighToneFC;
|
||||
int LeftHalfFCCnt = (LowToneFC % 2) + (LowToneFC/2); //truncate
|
||||
int FCs_per_clk = clk/LowToneFC;
|
||||
int FCs_per_clk = clk / LowToneFC;
|
||||
|
||||
// need to correctly split up the clock to field clocks.
|
||||
// First attempt uses modifiers on each end to make up for when FCs don't evenly divide into Clk
|
||||
|
|
@ -1860,14 +1852,14 @@ void GetHiLoTone(int *LowTone, int *HighTone, int clk, int LowToneFC, int HighTo
|
|||
for (i = 0; i < (FCs_per_clk); i++) {
|
||||
// loop # of samples per field clock
|
||||
for (j = 0; j < LowToneFC; j++) {
|
||||
LowTone[(i*LowToneFC)+Left_Modifier+j] = ( j < LeftHalfFCCnt ) ? 1 : -1;
|
||||
LowTone[ (i * LowToneFC) + Left_Modifier + j] = ( j < LeftHalfFCCnt ) ? 1 : -1;
|
||||
}
|
||||
}
|
||||
|
||||
int k;
|
||||
// add last -1 modifiers
|
||||
for (k = 0; k < Right_Modifier; k++) {
|
||||
LowTone[((i-1)*LowToneFC)+Left_Modifier+j+k] = -1;
|
||||
LowTone[ ( (i-1) * LowToneFC) + Left_Modifier + j + k] = -1;
|
||||
}
|
||||
|
||||
// now do hightone
|
||||
|
|
@ -1884,18 +1876,18 @@ void GetHiLoTone(int *LowTone, int *HighTone, int clk, int LowToneFC, int HighTo
|
|||
for (i = 0; i < (FCs_per_clk); i++) {
|
||||
// loop # of samples per field clock
|
||||
for (j = 0; j < HighToneFC; j++) {
|
||||
HighTone[(i*HighToneFC)+Left_Modifier+j] = ( j < LeftHalfFCCnt ) ? 1 : -1;
|
||||
HighTone[(i * HighToneFC) + Left_Modifier + j] = ( j < LeftHalfFCCnt ) ? 1 : -1;
|
||||
}
|
||||
}
|
||||
|
||||
// add last -1 modifiers
|
||||
for (k = 0; k < Right_Modifier; k++) {
|
||||
PrintAndLogEx(NORMAL, "(i-1)*HighToneFC+lm+j+k %i",((i-1)*HighToneFC)+Left_Modifier+j+k);
|
||||
HighTone[((i-1)*HighToneFC)+Left_Modifier+j+k] = -1;
|
||||
PrintAndLogEx(NORMAL, "(i-1)*HighToneFC+lm+j+k %i", ((i-1) * HighToneFC) + Left_Modifier + j + k);
|
||||
HighTone[ ( (i-1) * HighToneFC) + Left_Modifier + j + k] = -1;
|
||||
}
|
||||
if (g_debugMode == 2) {
|
||||
for ( i = 0; i < clk; i++) {
|
||||
PrintAndLogEx(NORMAL, "Low: %i, High: %i",LowTone[i],HighTone[i]);
|
||||
PrintAndLogEx(NORMAL, "Low: %i, High: %i", LowTone[i], HighTone[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1903,7 +1895,7 @@ void GetHiLoTone(int *LowTone, int *HighTone, int clk, int LowToneFC, int HighTo
|
|||
//old CmdFSKdemod adapted by marshmellow
|
||||
//converts FSK to clear NRZ style wave. (or demodulates)
|
||||
int FSKToNRZ(int *data, int *dataLen, int clk, int LowToneFC, int HighToneFC) {
|
||||
uint8_t ans=0;
|
||||
uint8_t ans = 0;
|
||||
if (clk == 0 || LowToneFC == 0 || HighToneFC == 0) {
|
||||
int firstClockEdge=0;
|
||||
ans = fskClocks((uint8_t *) &LowToneFC, (uint8_t *) &HighToneFC, (uint8_t *) &clk, &firstClockEdge);
|
||||
|
|
@ -1912,17 +1904,17 @@ int FSKToNRZ(int *data, int *dataLen, int clk, int LowToneFC, int HighToneFC) {
|
|||
}
|
||||
}
|
||||
// currently only know fsk modulations with field clocks < 10 samples and > 4 samples. filter out to remove false positives (and possibly destroying ask/psk modulated waves...)
|
||||
if (ans == 0 || clk == 0 || LowToneFC == 0 || HighToneFC == 0 || LowToneFC > 10 || HighToneFC < 4) {
|
||||
if (ans == 0 || clk == 0 || LowToneFC == 0 || HighToneFC == 0 || LowToneFC > 10 || HighToneFC < 4) {
|
||||
if (g_debugMode > 1) {
|
||||
PrintAndLog ("DEBUG FSKtoNRZ: no fsk clocks found");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int i, j;
|
||||
int LowTone[clk];
|
||||
int HighTone[clk];
|
||||
GetHiLoTone(LowTone, HighTone, clk, LowToneFC, HighToneFC);
|
||||
|
||||
int i, j;
|
||||
|
||||
// loop through ([all samples] - clk)
|
||||
for (i = 0; i < *dataLen - clk; ++i) {
|
||||
|
|
@ -1930,7 +1922,7 @@ int FSKToNRZ(int *data, int *dataLen, int clk, int LowToneFC, int HighToneFC) {
|
|||
|
||||
// sum all samples together starting from this sample for [clk] samples for each tone (multiply tone value with sample data)
|
||||
for (j = 0; j < clk; ++j) {
|
||||
lowSum += LowTone[j] * data[i+j];
|
||||
lowSum += LowTone[j] * data[i + j];
|
||||
highSum += HighTone[j] * data[i + j];
|
||||
}
|
||||
// get abs( [average sample value per clk] * 100 ) (or a rolling average of sorts)
|
||||
|
|
@ -1963,18 +1955,14 @@ int FSKToNRZ(int *data, int *dataLen, int clk, int LowToneFC, int HighToneFC) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int CmdFSKToNRZ(const char *Cmd) {
|
||||
// take clk, fc_low, fc_high
|
||||
// blank = auto;
|
||||
bool errors = false;
|
||||
int clk = 0;
|
||||
char cmdp = 0;
|
||||
int fc_low = 10, fc_high = 8;
|
||||
while(param_getchar(Cmd, cmdp) != 0x00)
|
||||
{
|
||||
switch (tolower(param_getchar(Cmd, cmdp)))
|
||||
{
|
||||
int clk = 0, fc_low = 10, fc_high = 8;
|
||||
while (param_getchar(Cmd, cmdp) != 0x00) {
|
||||
switch (tolower(param_getchar(Cmd, cmdp))) {
|
||||
case 'h':
|
||||
return usage_data_fsktonrz();
|
||||
case 'c':
|
||||
|
|
@ -1997,9 +1985,9 @@ int CmdFSKToNRZ(const char *Cmd) {
|
|||
if(errors) break;
|
||||
}
|
||||
//Validations
|
||||
if(errors) return usage_data_fsktonrz();
|
||||
if (errors) return usage_data_fsktonrz();
|
||||
|
||||
setClockGrid(0,0);
|
||||
setClockGrid(0, 0);
|
||||
DemodBufferLen = 0;
|
||||
int ans = FSKToNRZ(GraphBuffer, &GraphTraceLen, clk, fc_low, fc_high);
|
||||
CmdNorm("");
|
||||
|
|
@ -2007,17 +1995,15 @@ int CmdFSKToNRZ(const char *Cmd) {
|
|||
return ans;
|
||||
}
|
||||
|
||||
|
||||
int CmdDataIIR(const char *Cmd){
|
||||
uint8_t k = param_get8(Cmd,0);
|
||||
uint8_t k = param_get8(Cmd, 0);
|
||||
//iceIIR_Butterworth(GraphBuffer, GraphTraceLen);
|
||||
iceSimple_Filter(GraphBuffer, GraphTraceLen, k);
|
||||
RepaintGraphWindow();
|
||||
return 0;
|
||||
}
|
||||
|
||||
static command_t CommandTable[] =
|
||||
{
|
||||
static command_t CommandTable[] = {
|
||||
{"help", CmdHelp, 1, "This help"},
|
||||
{"askedgedetect", CmdAskEdgeDetect, 1, "[threshold] Adjust Graph for manual ASK demod using the length of sample differences to detect the edge of a wave (use 20-45, def:25)"},
|
||||
{"autocorr", CmdAutoCorr, 1, "[window length] [g] -- Autocorrelation over window - g to save back to GraphBuffer (overwrite)"},
|
||||
|
|
@ -2058,14 +2044,13 @@ static command_t CommandTable[] =
|
|||
{NULL, NULL, 0, NULL}
|
||||
};
|
||||
|
||||
int CmdData(const char *Cmd){
|
||||
int CmdData(const char *Cmd) {
|
||||
clearCommandBuffer();
|
||||
CmdsParse(CommandTable, Cmd);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int CmdHelp(const char *Cmd)
|
||||
{
|
||||
int CmdHelp(const char *Cmd) {
|
||||
CmdsHelp(CommandTable);
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue