Modern Read and/or Write Head for Writing and Reading to Magnetic Tape

I was looking to make a digital tape demo, where I basically create a budget version of the LTO tape with the help of the Arduino. I was wondering, if I want to avoid cracking open cassette tape players, as well as old cassette tape writers(that way I can have a repeatable kit that others can use), what parts would you recommend to use.
Also, would it be possible to get something more accurate that can read/write with a high linear density, and maybe even have more parallel tracks running along the tape?

That technology is completely obsolete - the only place you will ever find it is in esoteric devices that have some reason to be backwards compatible to 50 years ago. You will not be able to find new parts that do that anywhere at all, for reasonable prices anyway...

Heads out of old disk or diskette drives?

I guess that you don't know how complex is the electronics behind the head. It looks like you want to build a radio and ask for a suitable battery :frowning:

The message was, "I don't want to do that". By the way, I wonder what the heck an LTO tape is. Is that general knowledge?

Hi @itisyeetimetoday
Magnetic tapes are still used a lot in main frame environments.
They have features to record up to 30T bytes per spool and keep the data for many years.

The IBM TS2280 Tape Drive uses new generation LTO Ultrium 8 cartridges to store up to 30TB of compressed data per cartridge. And it records at the rate of 700 MBps.

But they have the disadvantage of being slow to fetch the data, as they are recorded in series.

To record on audio cassette type tapes, there are 2 track heads but the recording rate will be very low.

RV mineirin

Linear Tape Open (standard). I found drives available from $1500 to $4000. The use of an Arduino (which one?) won't make such drives really cheaper.

P.S.: everything below $3500 is refurbished.

Audio cassette players can be used as is, if they have a jack (usually labeled REM) that allows a microphone to switch the cassette drive motor on and off.

This one does, for example: https://www.amazon.com/Coby-Microphone-One-Touch-Recording-Automatic/dp/B0108A6000/

The data are usually encoded using 1200/2400 Hz frequency shift keying. Plenty of material on line describing the various formats. You need a voltage divider/low pass filter interface that reduces the 5V digital output stream to ~20 mV to mimic the microphone.

I did that a while back, using a different cassette recorder (get them for $1 at garage sales), as a lockdown project. Here is some test code that writes blocks of data to the tape.

#define cass_out 5
#define cass_mtr 4

unsigned char zeros[100] = {0};
unsigned char ones[100] = {0};
unsigned char aa[100] = {0};

// write data byte to cassette
void writeByte(unsigned char byte) {
  for (unsigned char i = 0; i < 8; i++) {
    if (byte & 1) { //1 = 1200 Hz
      digitalWrite(cass_out, 1);
      delayMicroseconds(416);
      digitalWrite(cass_out, 0);
      delayMicroseconds(416);
    }
    else { //0 = 2400 Hz
      digitalWrite(cass_out, 1);
      delayMicroseconds(208);
      digitalWrite(cass_out, 0);
      delayMicroseconds(208);
    }
    byte = byte >> 1;
  }
}

// write data block to cassette (global dataBlock)
// writes an MC-10 block

void writeBlock(unsigned char block[], unsigned char blocksize, unsigned char type) {

  unsigned char c, i, checksum = 0;

  writeByte(0x55); //leader
  writeByte(0x3C); //sync char
  writeByte(type); //0=file name, 1=data 0xFF=EOF
  writeByte(blocksize);
  if (blocksize > 0) {
    for (i = 0; i < blocksize; i++) {
      c = block[i];
      checksum += c;
      writeByte(c);
    }
  }
  checksum += type;
  checksum += blocksize;
  writeByte(checksum);
  writeByte(0x55); //trailer
}

// function to write tape leader, 128 bytes of 0x55

void leader(void) {
  for (unsigned char i = 0; i < 128; i++) writeByte(0x55);
}

void setup() {
  // put your setup code here, to run once:
  int i;
  pinMode(cass_out, OUTPUT);
  pinMode(cass_mtr, OUTPUT);
  Serial.begin(115200);
  delay(100);
  Serial.println("start");
  for (i = 0; i < 100; i++) {
    ones[i] = 0x11;
    aa[i] = 0xaa;
  }
  digitalWrite(cass_out, 0); //idle
  digitalWrite(cass_mtr, 0); //motor off

  digitalWrite(cass_mtr, 1); //motor on
  delay(5000);  //skip blank tape
  //zeros
  noInterrupts();
  leader(); //write tape leader
  writeBlock(zeros, 10, 1); //first data block
  //ones
  writeBlock(ones, 10, 1); //second data block
  //0xAA
  writeBlock(aa, 10, 1); //third
  writeBlock(aa, 0, 0xFF); //End Of File
  interrupts();
  delay(2000); //file gap
  digitalWrite(cass_mtr, 0); //motor off
  Serial.println("done");
}

void loop() {
  // put your main code here, to run repeatedly:

}

Recording is the easy part, reading back requires more soft- and hardware.

BTW recorders without tape counter turned out quite useless for program or data storage.

Thank you for the response. I do know about LTO tape, but they are very very expensive to get recorders and tapes(compared to the amount I want to spend for this project), and I don't think cracking open those readers/writers would be a good idea for me. My goal is basically to make a simple demo that people can use to show people how the tech works, kinda like those transparent hard drives that Seagate has to show off new tech, but instead for a tape.

LTO tape seems to be enterprise-level archive drives that are used to back up a very very large of data, often on the scale of petabytes or even more. My goal is to make a demo to show how they work, without using actual drives.

I see, but I was wondering where I could get sensor for reading and writing data in general, where my performance isn't too big of a concern. I would be willing to write across the entire tape if necessary, with one big "file" being stored.

You don't get a sensor that connects easily to an Arduino. Most easily it connects an existing recorder, as already mentioned.

If you want to build more yourself then you need at least tape moving and winding mechanics, tape duct and speed control, carrier frequency generator, means for signal erasure, write coil driver and read coil amplifier. If you don't have an idea of any of these items then you better start with dissecting existing recorders and learn how their items are constructed.

I doubt you will find anything remotely modern that would be easily interfaced to an arduino. Older tape drives from the 70's or 80's that took open reels of tape would probably work, since they were often designed for simple parallel data interfaces. Most if not all modern stuff will be SCSI, SATA, or something similarly complex. I actually bought one of those, with the accompanying rack cabinet, for almost nothing back in the mid 80's when the local Western Electric factory closed and sold off all their equipment.

There are some fairly cheap LTO cartridge drives on ebay ($50 or so), if you want to deal with a real device, but there is basically nothing to see unless you want to strip the entire case off and hope everything still holds together at that point.