200 lines
8.0 KiB
C++
200 lines
8.0 KiB
C++
#ifndef READERWRITER_ROTATION_EXTRACTOR
|
|
#define READERWRITER_ROTATION_EXTRACTOR
|
|
/* ArduinoFloppyReader (and writer) - Rotation Extractor
|
|
*
|
|
* Copyright (C) 2017-2021 Robert Smith (@RobSmithDev)
|
|
* https://amiga.robsmithdev.co.uk
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 3 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public
|
|
* License along with this library; if not, see http://www.gnu.org/licenses/
|
|
*/
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////
|
|
// Class to manage finding *exact* disk revolutions //
|
|
////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Purpose:
|
|
// The class attempts to guess where an exact disk revolution occurs, and then re-aligns
|
|
// it such that it starts at the index pulse. This means we dont need to wait for an index
|
|
// pulse to work out a revolution of the disk. The first time a disk is used we calculate
|
|
// the time of a single revolution and then use that as a guide to how long a revolution will
|
|
// take in the future.
|
|
//
|
|
// This isn't 100% perfect but does seem to work.
|
|
|
|
// With this defined you get speed data per bit. Undefined, per 8 bits. Nothing seems to notice much
|
|
// Inside *UAE it uses one speed value for 16 bits of MFM data so that's probably why.
|
|
// and besides, with this *undefined* we save about 700k of ram
|
|
#define HIGH_RESOLUTION_MODE
|
|
|
|
// Instead of outputting "speed" values this will output bit-times in ns
|
|
#define OUTPUT_TIME_IN_NS
|
|
|
|
// So worse case is the disk takes 210ms to spin, and every sequence is VERY fast, and every sequence is 01, this number is highly unlikely though
|
|
#define MAX_REVOLUTION_SEQUENCES 110000
|
|
|
|
// Number of sequences to match to find the index overlap position or the rotation overlap position
|
|
// The higher the number, the more chance of perfect revolution alignment, but higher processing required at the end of each revolution
|
|
#define OVERLAP_SEQUENCE_MATCHES 1024
|
|
|
|
// Extra window either side. this allows more of a search range
|
|
#define OVERLAP_EXTRA_BUFFER 6
|
|
|
|
// Signal for index was not found
|
|
#define INDEX_NOT_FOUND 0xFFFFFFFF
|
|
|
|
|
|
// Class to extract a single rotation from an incoming mfm data sequence.
|
|
class RotationExtractor {
|
|
public:
|
|
|
|
// Enum for the possible sequences we support
|
|
enum class MFMSequence : unsigned char { mfm01 = 0, mfm001 = 1, mfm0001 = 2, mfm0000 = 3 };
|
|
|
|
// A single sequence of MFM data
|
|
struct MFMSequenceInfo {
|
|
// Total time it took to read this in NS
|
|
unsigned short timeNS;
|
|
|
|
// The MFM sequence discovered
|
|
MFMSequence mfm;
|
|
};
|
|
|
|
// Decoded version of the above
|
|
struct MFMSample {
|
|
#ifdef OUTPUT_TIME_IN_NS
|
|
// This is the time for each 'bit'
|
|
unsigned short bittime[8];
|
|
#else
|
|
#ifdef HIGH_RESOLUTION_MODE
|
|
// This is the speed of each 'bit' as a %
|
|
unsigned short speed[8];
|
|
#else
|
|
// This is the average speed of all 8 bits as a %
|
|
unsigned short speed;
|
|
#endif
|
|
#endif
|
|
|
|
// This is the raw MFM bit-data
|
|
unsigned char mfmData;
|
|
};
|
|
|
|
// Struct for tracking what the index start looks like so we get it perfect (or at least consistant)
|
|
struct IndexSequenceMarker {
|
|
// Sequences found
|
|
MFMSequence sequences[OVERLAP_SEQUENCE_MATCHES];
|
|
|
|
// If this is actually valid
|
|
bool valid = false;
|
|
};
|
|
|
|
private:
|
|
// How long a revolution is
|
|
unsigned int m_revolutionTime = 0;
|
|
// An amount of time whereby we 'nearly' have a complete revolution of data
|
|
unsigned int m_revolutionTimeNearlyComplete = 0;
|
|
// Used while working out the above
|
|
unsigned int m_revolutionTimeCounting = 0;
|
|
// Where the first index pulse was discovered
|
|
unsigned int m_sequenceIndex = INDEX_NOT_FOUND;
|
|
// Where the second index pulse was discovered
|
|
unsigned int m_nextSequenceIndex = INDEX_NOT_FOUND;
|
|
// Where we were when we reached m_revolutionTime worth of data
|
|
unsigned int m_revolutionReadyAt = INDEX_NOT_FOUND;
|
|
// And a flag to set this as good
|
|
bool m_revolutionReady = false;
|
|
// If we should always use the index marker when finding revolutions
|
|
bool m_useIndex = false;
|
|
// Current amount of data in the buffer in ns
|
|
unsigned int m_currentTime = 0;
|
|
// Current position of the buffer
|
|
unsigned int m_sequencePos = 0;
|
|
// Used to track exactly how much data has been submitted
|
|
unsigned int m_timeReceived = 0;
|
|
// Sequences received thus far
|
|
MFMSequenceInfo m_sequences[MAX_REVOLUTION_SEQUENCES];
|
|
// In index mode, this holds the initial sequences before the first index marker
|
|
MFMSequenceInfo m_initialSequences[OVERLAP_SEQUENCE_MATCHES * OVERLAP_EXTRA_BUFFER];
|
|
// Length of the above datat in use
|
|
unsigned int m_initialSequencesLength = 0;
|
|
// Where we're writing to as its a circular buffer
|
|
unsigned int m_initialSequencesWritePos = 0;
|
|
// Sequences discovered around the index marker
|
|
IndexSequenceMarker m_indexSequence;
|
|
|
|
// Finds the overlap between the start of the data and where we currently are
|
|
unsigned int getOverlapPosition() const;
|
|
|
|
// is almost identical
|
|
const unsigned int getTrueIndexPosition(const unsigned int revolutionEnd, const unsigned int startingPoint = INDEX_NOT_FOUND);
|
|
public:
|
|
// Get and set the sequence identified as data round the INDEX pulse so that next time we get consistant revolution starting points
|
|
void setIndexSequence(const IndexSequenceMarker& sequence) { m_indexSequence = sequence; }
|
|
void getIndexSequence(IndexSequenceMarker& sequence) const { sequence = m_indexSequence; }
|
|
|
|
// Reset this back to "empty"
|
|
inline void reset() {
|
|
m_indexSequence.valid = false;
|
|
m_revolutionReadyAt = INDEX_NOT_FOUND;
|
|
m_sequencePos = 0;
|
|
m_sequenceIndex = INDEX_NOT_FOUND;
|
|
m_nextSequenceIndex = INDEX_NOT_FOUND;
|
|
m_currentTime = 0;
|
|
m_revolutionReady = false;
|
|
m_initialSequencesLength = 0;
|
|
m_initialSequencesWritePos = 0;
|
|
m_timeReceived = 0;
|
|
}
|
|
|
|
// Signal new disk, or maybe a motor restarted. Need to re-calculate rotation speed
|
|
inline void newDisk() {
|
|
reset();
|
|
m_revolutionTime = 0;
|
|
m_revolutionTimeCounting = 0;
|
|
m_revolutionTimeNearlyComplete = 0;
|
|
}
|
|
|
|
// Return the current revolution time
|
|
inline unsigned int getRevolutionTime() const { return m_revolutionTime; };
|
|
|
|
// Set the current revolution time
|
|
inline void setRevolutionTime(const unsigned int time) { m_revolutionTime = time; m_revolutionTimeNearlyComplete = (unsigned int)(time * 0.9f); };
|
|
|
|
// Return the total amount of time data received so far
|
|
inline unsigned int totalTimeReceived() const { return m_timeReceived; };
|
|
|
|
// Returns TRUE if this has learnt the time of a disk revolution
|
|
inline bool hasLearntRotationSpeed() const { return m_revolutionTime > 150000000; };
|
|
|
|
// Returns TRUE if we're in INDEX mode
|
|
inline bool isInIndexMode() const { return m_useIndex; };
|
|
|
|
// Sets the code so it always uses the index marker when finding revolutions
|
|
void setAlwaysUseIndex(bool useIndex) { m_useIndex = useIndex; };
|
|
|
|
// If this is about to spit out a revolution in a very small amount of time
|
|
inline bool isNearlyReady() const { return (m_revolutionTimeNearlyComplete) && (m_currentTime >= m_revolutionTimeNearlyComplete) && (!m_useIndex); }
|
|
|
|
// Submit a single sequence to the list
|
|
void submitSequence(const MFMSequenceInfo& sequence, const bool isIndex);
|
|
|
|
// Returns TRUE if we should be able to extract a revolution
|
|
inline bool canExtract() const { return (m_revolutionReadyAt != INDEX_NOT_FOUND) && (m_revolutionReady); };
|
|
|
|
// Extracts a single rotation and updates the buffer to remove it. Returns FALSE if no rotation is available
|
|
// If calculateSpeedFactor is true, we're in INDEX mode, and HIGH_RESOLUTION_MODE is defined then this will output time in NS rather than the speed factor value
|
|
bool extractRotation(MFMSample* output, unsigned int& outputBits, const unsigned int maxBufferSizeBytes);
|
|
};
|
|
|
|
|
|
#endif |