salfter/fluxengine
1
0
Fork 0
mirror of https://github.com/davidgiven/fluxengine.git synced 2025-10-31 11:17:01 -07:00
Code Issues Packages Projects Releases Wiki Activity

Rework the Victor 9000 decoder to use the new architecture.

Browse Source
This commit is contained in:
David Given
2019-04-19 14:39:26 +02:00
parent 5f8e0c846c
commit 2ddc1045ec
6 changed files with 93 additions and 144 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
lib/decoders/fluxmapreader.cc
View File

@@ -3,6 +3,7 @@
#include "fluxmapreader.h"
#include "flags.h"
#include "protocol.h"
#include "fmt/format.h"
#include <numeric>
#include <math.h>
@@ -11,6 +12,11 @@ static DoubleFlag clockDecodeThreshold(
"Amount of error to tolerate in pulse timing.",
0.30);
static DoubleFlag clockIntervalBias(
{ "--clock-interval-bias" },
"Adjust intervals between pulses by this many clocks before decoding.",
-0.02);
int FluxmapReader::readOpcode(unsigned& ticks)
{
ticks = 0;
@@ -176,9 +182,8 @@ bool FluxmapReader::readRawBit(nanoseconds_t clockPeriod)
return false;
}
unsigned interval = readNextMatchingOpcode(F_OP_PULSE);
unsigned clockTicks = clockPeriod / NS_PER_TICK;
double clocks = (double)interval / clockTicks;
nanoseconds_t interval = readNextMatchingOpcode(F_OP_PULSE)*NS_PER_TICK;
double clocks = (double)interval / clockPeriod + clockIntervalBias;
if (clocks < 1.0)
clocks = 1.0;
@@ -190,7 +195,10 @@ std::vector<bool> FluxmapReader::readRawBits(unsigned count, nanoseconds_t clock
{
std::vector<bool> result;
while (!eof() && count--)
result.push_back(readRawBit(clockPeriod));
{
bool b = readRawBit(clockPeriod);
result.push_back(b);
}
return result;
}

5
lib/decoders/fluxmapreader.h
View File

@@ -85,7 +85,10 @@ public:
{ return _pos; }
void seek(const Fluxmap::Position& pos)
{ _pos = pos; _pendingZeroBits = 0; }
{
_pos = pos;
_pendingZeroBits = 0;
}
int readOpcode(unsigned& ticks);
unsigned readNextMatchingOpcode(uint8_t opcode);

24
lib/reader.cc
View File

@@ -179,18 +179,6 @@ void readDiskCommand(AbstractDecoder& decoder, const std::string& outputFilename
if (hasBadSectors)
failures = false;
if (dumpRecords && (!hasBadSectors || (retry == 0) || !track->fluxsource->retryable()))
{
std::cout << "\nRaw (undecoded) records follow:\n\n";
for (auto& record : track->rawrecords)
{
std::cout << fmt::format("I+{:.2f}us", record.position.ns() / 1000.0)
<< std::endl;
hexdump(std::cout, record.data);
std::cout << std::endl;
}
}
std::cout << std::endl
<< " ";
@@ -210,6 +198,18 @@ void readDiskCommand(AbstractDecoder& decoder, const std::string& outputFilename
}
}
if (dumpRecords)
{
std::cout << "\nRaw (undecoded) records follow:\n\n";
for (auto& record : track->rawrecords)
{
std::cout << fmt::format("I+{:.2f}us", record.position.ns() / 1000.0)
<< std::endl;
hexdump(std::cout, record.data);
std::cout << std::endl;
}
}
int size = 0;
bool printedTrack = false;
for (auto& i : readSectors)

157
lib/victor9k/decoder.cc
View File

@@ -1,5 +1,6 @@
#include "globals.h"
#include "fluxmap.h"
#include "fluxmapreader.h"
#include "protocol.h"
#include "record.h"
#include "decoders.h"
@@ -12,6 +13,9 @@
#include <string.h>
#include <algorithm>
const FluxPattern SECTOR_RECORD_PATTERN(32, VICTOR9K_SECTOR_RECORD);
const FluxPatterns SECTOR_OR_DATA_RECORD_PATTERN(32, { VICTOR9K_SECTOR_RECORD, VICTOR9K_DATA_RECORD });
static int decode_data_gcr(uint8_t gcr)
{
switch (gcr)
@@ -49,122 +53,57 @@ static Bytes decode(const std::vector<bool>& bits)
return output;
}
SectorVector Victor9kDecoder::decodeToSectors(const RawRecordVector& rawRecords, unsigned, unsigned)
nanoseconds_t Victor9kDecoder::findSector(FluxmapReader& fmr, Track& track)
{
std::vector<std::unique_ptr<Sector>> sectors;
unsigned nextSector;
unsigned nextTrack;
unsigned nextSide;
bool headerIsValid = false;
for (auto& rawrecord : rawRecords)
{
const auto& rawdata = rawrecord->data;
const auto& bytes = decode(rawdata);
if (bytes.size() == 0)
continue;
switch (bytes[0])
{
case 7: /* sector record */
{
headerIsValid = false;
if (bytes.size() < 6)
break;
uint8_t rawTrack = bytes[1];
nextSector = bytes[2];
uint8_t gotChecksum = bytes[3];
nextTrack = rawTrack & 0x7f;
nextSide = rawTrack >> 7;
uint8_t wantChecksum = bytes[1] + bytes[2];
if (wantChecksum != gotChecksum)
break;
if ((nextSector > 20) || (nextTrack > 85) || (nextSide > 1))
break;
headerIsValid = true;
break;
}
case 8: /* data record */
{
if (!headerIsValid)
break;
headerIsValid = false;
if (bytes.size() < VICTOR9K_SECTOR_LENGTH+3)
break;
Bytes payload = bytes.slice(1, VICTOR9K_SECTOR_LENGTH);
uint16_t gotChecksum = sumBytes(payload);
uint16_t wantChecksum = bytes.reader().seek(VICTOR9K_SECTOR_LENGTH+1).read_le16();
int status = (gotChecksum == wantChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
auto sector = std::unique_ptr<Sector>(
new Sector(status, nextTrack, nextSide, nextSector, payload));
sectors.push_back(std::move(sector));
break;
}
}
}
return sectors;
return fmr.seekToPattern(SECTOR_RECORD_PATTERN);
}
int Victor9kDecoder::recordMatcher(uint64_t fifo) const
nanoseconds_t Victor9kDecoder::findData(FluxmapReader& fmr, Track& track)
{
uint32_t masked = fifo & 0xfffff;
if ((masked == VICTOR9K_SECTOR_RECORD) || (masked == VICTOR9K_DATA_RECORD))
return 9;
return 0;
return fmr.seekToPattern(SECTOR_OR_DATA_RECORD_PATTERN);
}
nanoseconds_t Victor9kDecoder::guessClockImpl(Track& track) const
void Victor9kDecoder::decodeHeader(FluxmapReader& fmr, Track& track, Sector& sector)
{
const nanoseconds_t BASE_CLOCK = 2065;
const double BASE_SPEED = 167.0;
/* Skip the sync marker bit. */
fmr.readRawBits(23, sector.clock);
unsigned trackid = track.physicalTrack;
switch (track.physicalSide)
{
case 0:
if (trackid < 4)
return BASE_CLOCK * BASE_SPEED / 237.9;
else if (trackid < 16)
return BASE_CLOCK * BASE_SPEED / 224.5;
else if (trackid < 27)
return BASE_CLOCK * BASE_SPEED / 212.2;
else if (trackid < 38)
return BASE_CLOCK * BASE_SPEED / 199.9;
else if (trackid < 49)
return BASE_CLOCK * BASE_SPEED / 187.6;
else if (trackid < 60)
return BASE_CLOCK * BASE_SPEED / 175.3;
else if (trackid < 71)
return BASE_CLOCK * BASE_SPEED / 163.0;
else
return BASE_CLOCK * BASE_SPEED / 149.6;
case 1:
if (trackid < 8)
return BASE_CLOCK * BASE_SPEED / 224.5;
else if (trackid < 19)
return BASE_CLOCK * BASE_SPEED / 212.2;
else if (trackid < 30)
return BASE_CLOCK * BASE_SPEED / 199.9;
else if (trackid < 41)
return BASE_CLOCK * BASE_SPEED / 187.6;
else if (trackid < 52)
return BASE_CLOCK * BASE_SPEED / 175.3;
else if (trackid < 63)
return BASE_CLOCK * BASE_SPEED / 163.0;
else if (trackid < 75)
return BASE_CLOCK * BASE_SPEED / 149.6;
else
return BASE_CLOCK * BASE_SPEED / 144.0;
}
/* Read header. */
throw "unreachable";
auto bytes = decode(fmr.readRawBits(4*10, sector.clock)).slice(0, 4);
uint8_t rawTrack = bytes[1];
sector.logicalSector = bytes[2];
uint8_t gotChecksum = bytes[3];
sector.logicalTrack = rawTrack & 0x7f;
sector.logicalSide = rawTrack >> 7;
uint8_t wantChecksum = bytes[1] + bytes[2];
if ((sector.logicalSector > 20) || (sector.logicalTrack > 85) || (sector.logicalSide > 1))
return;
if (wantChecksum == gotChecksum)
sector.status = Sector::DATA_MISSING; /* unintuitive but correct */
}
void Victor9kDecoder::decodeData(FluxmapReader& fmr, Track& track, Sector& sector)
{
/* Skip the sync marker bit. */
fmr.readRawBits(23, sector.clock);
/* Read data. */
auto bytes = decode(fmr.readRawBits((VICTOR9K_SECTOR_LENGTH+5)*10, sector.clock))
.slice(0, VICTOR9K_SECTOR_LENGTH+5);
ByteReader br(bytes);
/* Check that this is actually a data record. */
if (br.read_8() != 8)
return;
sector.data = br.read(VICTOR9K_SECTOR_LENGTH);
uint16_t gotChecksum = sumBytes(sector.data);
uint16_t wantChecksum = br.read_le16();
sector.status = (gotChecksum == wantChecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
}

15
lib/victor9k/victor9k.h
View File

@@ -1,24 +1,23 @@
#ifndef VICTOR9K_H
#define VICTOR9K_H
#define VICTOR9K_SECTOR_RECORD 0xffeab
#define VICTOR9K_DATA_RECORD 0xffea4
#define VICTOR9K_SECTOR_RECORD 0xfffffeab
#define VICTOR9K_DATA_RECORD 0xfffffea4
#define VICTOR9K_SECTOR_LENGTH 512
class Sector;
class Fluxmap;
class Victor9kDecoder : public AbstractStatefulDecoder
class Victor9kDecoder : public AbstractSplitDecoder
{
public:
virtual ~Victor9kDecoder() {}
SectorVector decodeToSectors(
const RawRecordVector& rawRecords, unsigned physicalTrack, unsigned physicalSide);
int recordMatcher(uint64_t fifo) const;
nanoseconds_t guessClockImpl(Track& track) const;
nanoseconds_t findSector(FluxmapReader& fmr, Track& track) override;
nanoseconds_t findData(FluxmapReader& fmr, Track& track) override;
void decodeHeader(FluxmapReader& fmr, Track& track, Sector& sector) override;
void decodeData(FluxmapReader& fmr, Track& track, Sector& sector) override;
};
#endif

20
meson.build
View File

@@ -222,15 +222,15 @@ macdecoderlib = declare_dependency(
# include_directories:
# include_directories('lib/zilogmcz')
#)
#
#victor9kdecoderlib = declare_dependency(
# link_with:
# shared_library('victor9kdecoderlib',
# [ 'lib/victor9k/decoder.cc', ],
# dependencies: [fmtlib, felib, decoderlib]),
# include_directories:
# include_directories('lib/victor9k')
#)
victor9kdecoderlib = declare_dependency(
link_with:
shared_library('victor9kdecoderlib',
[ 'lib/victor9k/decoder.cc', ],
dependencies: [fmtlib, felib, decoderlib]),
include_directories:
include_directories('lib/victor9k')
)
executable('fe-erase', ['src/fe-erase.cc'], dependencies: [felib, writerlib])
executable('fe-inspect', ['src/fe-inspect.cc'], dependencies: [fmtlib, felib, decoderlib, readerlib])
@@ -247,7 +247,7 @@ executable('fe-readfb100', ['src/fe-readfb100.cc'], dependencies
#executable('fe-readibm', ['src/fe-readibm.cc'], dependencies: [fmtlib, felib, decoderlib, readerlib, ibmdecoderlib])
executable('fe-readmac', ['src/fe-readmac.cc'], dependencies: [fmtlib, felib, decoderlib, readerlib, macdecoderlib])
#executable('fe-readzilogmcz', ['src/fe-readzilogmcz.cc'], dependencies: [fmtlib, felib, decoderlib, readerlib, zilogmczdecoderlib])
#executable('fe-readvictor9k', ['src/fe-readvictor9k.cc'], dependencies: [fmtlib, felib, decoderlib, readerlib, victor9kdecoderlib])
executable('fe-readvictor9k', ['src/fe-readvictor9k.cc'], dependencies: [fmtlib, felib, decoderlib, readerlib, victor9kdecoderlib])
executable('fe-rpm', ['src/fe-rpm.cc'], dependencies: [fmtlib, felib])
executable('fe-seek', ['src/fe-seek.cc'], dependencies: [fmtlib, felib])
executable('fe-testbulktransport', ['src/fe-testbulktransport.cc'], dependencies: [fmtlib, felib])