Function mainAnalyseDriveResponse

src/fe-analysedriveresponse.cc:245–466

}

int mainAnalyseDriveResponse(int argc, const char* argv[])
{
    globalConfig().overrides()->mutable_flux_source()->set_type(FLUXTYPE_DRIVE);
    flags.parseFlagsWithConfigFiles(argc, argv, {});

    if (globalConfig()->flux_sink().type() != FLUXTYPE_DRIVE)
        error("this only makes sense with a real disk drive");
    auto tracks = parseCylinderHeadsString(destTracks);
    if (tracks.size() != 1)
        error("you must specify exactly one track");

    usbSetDrive(globalConfig()->drive().drive(),
        globalConfig()->drive().high_density(),
        globalConfig()->drive().index_mode());
    usbSeek(tracks[0].cylinder);

    std::cout << "Measuring rotational speed...\n";
    nanoseconds_t period = usbGetRotationalPeriod(0);
    if (period == 0)
        error("Unable to measure rotational speed (try fluxengine rpm).");

    std::ofstream csv;
    if (writeCsv.get() != "")
        csv.open(writeCsv);

    int numRows = (maxInterval - minInterval) / intervalStep;
    const int numColumns = buckets;
    std::vector<std::vector<double>> frequencies(
        numRows, std::vector<double>(numColumns, 0.0));

    double interval;
    for (int row = 0; row < numRows; row++)
    {
        interval = minInterval + (double)row * intervalStep;

        unsigned ticks = (unsigned)(interval * TICKS_PER_US);
        std::cout << fmt::format("Interval {:.2f}: ", ticks * US_PER_TICK);
        std::cout << std::flush;

        /* Write the test pattern. */

        if (interval >= 2.0)
        {
            Fluxmap outFluxmap;
            while (outFluxmap.duration() < period)
            {
                outFluxmap.appendInterval(ticks);
                outFluxmap.appendPulse();
            }

            usbWrite(tracks[0].head, outFluxmap.rawBytes(), 0);

            /* Read the test pattern in again. */

            Fluxmap inFluxmap;
            inFluxmap.appendBytes(usbRead(tracks[0].head, true, period, 0));

            /* Compute histogram. */