Is it possible to write to an unformated SD?

In a project I need to write only a single block of data up to 500 MB as an array of bytes to SD and
read them when needed. It will only be done by Arduino. No file name is needed.

When its time to write the new data, in fact, I will overwrite total 500 MB or a block of data to SD

So, may I write and read repeatedly without a file system?

So, may I write and read repeatedly without a file system?

Yes you can write without a file system. You must buffer data and write in 512 byte blocks.

You should use the new SdFat-beta. If you use SD.h, you may lose 500-600 bytes of RAM since the SD object is always defined and contains a 512 byte cache.

SdFat will not define the file system object. Here is an example using this version of SdFat-beta.

#include <SdFat.h>
const uint8_t CS_PIN = 4;

Sd2Card card;

uint8_t buf[512];

// buf as uint32_t
uint32_t* buf32 = (uint32_t*)buf;

// card logical block number
uint32_t lbn;

void setup() {
  Serial.begin(9600);
  if (!card.begin(CS_PIN)) {
    Serial.println(F("card.begin failed"));
    return;
  }
  // write first 1000 blocks with lbn in first four bytes.
  for (lbn = 0; lbn < 1000; lbn++) {
    buf32[0] = lbn;
    if (!card.writeBlock(lbn, buf)) {
      Serial.println(F("card.write failed"));
      return;
    }
  }
  // read first 1000 blocks and print first four bytes as uint32_t
    for (lbn = 0; lbn < 1000; lbn++) {
    if (!card.readBlock(lbn, buf)) {
      Serial.println(F("card.read failed"));
      return;
    }
    Serial.println(buf32[0]);
  }
}
void loop() {}

Here is a faster way to write/read using single multi-block transfers.

#include <SdFat.h>
const uint8_t CS_PIN = 10;

Sd2Card card;

uint8_t buf[512];

// buf as uint32_t
uint32_t* buf32 = (uint32_t*)buf;

//card logical block number
uint32_t lbn;

void setup() {
  Serial.begin(9600);

  if (!card.begin(CS_PIN)) {
    Serial.println(F("card.begin failed"));
    return;
  }
  uint32_t m = micros();
  // write first 1000 blocks with lbn in first four bytes.
  // Start multi block write of 1000 blocks at lbn 0
  if (!card.writeStart(0, 1000)) {
    Serial.println(F("write start failed"));
    return;
  }
  for (lbn = 0; lbn < 1000; lbn++) {
    buf32[0] = lbn;
    if (!card.writeData(buf)) {
      Serial.println(F("card.write failed"));
      return;
    }
  }
  if (!card.writeStop()) {
    Serial.println(F("write stop failed"));
    return;
  }
  m = micros() - m;
  // read first 1000 blocks and print first four bytes as uint32_t
  // Start at lbn 0
  if (!card.readStart(0)) {
    Serial.println(F("read start failed"));
    return;
  }
  for (lbn = 0; lbn < 1000; lbn++) {
    if (!card.readData(buf)) {
      Serial.println(F("card.read failed"));
      return;
    }
    Serial.println(buf32[0]);
  }
  if (!card.readStop()) {
    Serial.println(F("read stop failed"));
    return;
  }
  // print write time in us
  Serial.print("us: ");
  Serial.println(m);
}
void loop() {}

This program writes 1000 blocks in about 0.715 seconds. so writing 1,000,000 blocks would take about 715 seconds.

Read will take about 810 seconds.

this opens the way to an "Arduino File System" - not that we need another one, but still...