If you want to find a correct SD card on internet today, you will need to do a small homework
Those SD cards from link you send Samsung EVO (yellow color) it doesent matter if SD is normal size or micro, all depends of year of production
So if you want to buy correct SD on Ebay or Amazon for changing CID which works with FAMOUS MMC contact every seller and ask him to check you back label
Below the label on the left is written SAMSUNG ELECTRONIC, there you will see small number its year of production of SD
Now for this yellow color type SD 8GB, 16GB, 32GB, 64GB, 128GB size the year of production MUST be 2012,2013,2014
If year of production is 2015, 2016, 2017 CID change works with different MMC
For red color type (evo+) year of production must be 2014,2015,2016
If year of production is 2017 and latest 2018 CID change works with different MMC
thats it.
I suggest you to skip everything, you only write in ebay browser CID changable SD
[Only registered and activated users can see links. ]
One guy do his homework, he find few SDs from old stock, you can get one SDs from him
I have some SD cards that I use. Is there a limit to how many times I can write over them? If I leave information on a card, is there anything that can cause it to lose this information eventually (other than a magnetic field)? What's the preferred storage conditions for these cards?
Flash memory indeed has limited write cycles. However, by now it is unlikely that you'll encounter this within the normal lifetime of such a card. Usually this is in the order of 100,000 write cycles today and SD cards include circuitry to manage wear-leveling, that is, spread out writes over the storage media evenly to avoid 'hot spots'—pages that are written too frequently and therefore failing early.
Information stored on the card is safe even in magnetic fields because the information is not stored magnetically (contrary to hard drives or floppy disks).
As for storage conditions ... you shouldn't store them in mud, water, lava or other harmful conditions. You probably also shouldn't put them on railways and let trains drive over them. Apart from that, not paying particular attention where I store my cards I haven't had any adverse effects so far. In practice I'd think whatever doesn't physically damage the card won't harm the data on it.
Never trust FLASH memory of any kind for long term storage. My experience with FLASH is integrity begins to falter in as little as 5 years. The voltages stored in the FLASH memory cells dissipate and can be misinterpreted after a while. High temperatures will accelerate the dissipation and shorten storage even less than 5 years.
High density FLASH where one cell can represent 2 bits has greatest failure rate.. most common in use as it is the cheapest to manufacture (double capacity). Many FLASH micro-controller applications are failing after 5-10 years because of FLASH memory corruption. Re-FLASHing the firmware restores the chip for another 5-10 years etc. So you must refresh FLASH memory data periodically to ensure continued integrity. Same would apply if you wanted to use the SD card as long term storage.
The FLASH memory chip itself is extremely rugged and can offer hundreds, if not thousands of years of service; as long as maximum write cycle lifespan has not been exceeded. FLASH memory cells are like millions of individual microscopic batteries that are charged at different levels. As you know, any battery new in the pack sitting on a shelf for years will eventually discharge. Same applies to FLASH memory cells, they require 'recharging' periodically to maintain proper charges which represent data bits. So a FLASH memory card put into a safety deposit box for 25 years... guaranteed you will have corrupt data when you try to use it. I have seen FLASH memory with 20% corruption after 10 years of sitting in storage.
FLASH thumb drives are great for transferring data from one computer to another etc, but NEVER to be used for long term archival storage. Same goes for the conventional CD ROM. After 5-10 years, the contrast dye will fail causing read errors.
The best medium for long term storage are ARCHIVAL GOLD CD-R or similar brand. The storage medium on the disk is a thin layer of 24K gold so it will not oxidize. Data retention on this type of CD is expected to be intact even after 300 years. They are expensive compared to conventional CD-R.
Durability
In my experience, memory cards are quite durable, though occasionally finicky when it comes to formats. I recently ran a cellphone through the washing machine (it was so dirty), and the 2 GB microSD card works just fine in my new phone (I eventually got the washed phone working too, but it was a good excuse to upgrade).
Rob Galbraith, who maintains an amazing website on CompactFlash and Secure Digital cards, says
Individual flash memory cells have a limited lifespan. That's the bad news. The good news is that their lifespan is usually measured in the many, many thousands of erase/write cycles, and that card controllers use an algorithm that balances the wear across the entire card's cells. CompactFlash and SD/SDHC cards are designed to automatically and transparently map out memory cells that go bad, or in some cases when they reach a predefined limit.
Write cycles are important, but MTBF (mean time between failures) is often 1M-2M hours or more, factoring in advances such as wear leveling, bad-block marking and management, etc.
Tips
Anecdotes
The 2004 BBC article Digital memories survive extremes covers an interesting study by Digital Camera Shopper on the durability of memory cards.
The memory cards in most cameras are virtually indestructible, found Digital Camera Shopper magazine. Five memory card formats survived being boiled, trampled, washed and dunked in coffee or cola.
In 2004, there was an incident (covered happily in a SanDisk press release at the time) where a photographer's compact flash card survived a bridge explosion where the camera gear was set up so close to the blast that it was destroyed, but the CompactFlash card survived. Other incidents like plane crashes are hyped by SanDisk so much that, admittedly, I get nervous using other brands. That said, it's not always easy to get data from a damaged card. An atmospheric research balloon crashed in the Pacific Ocean and was recovered. One SD card was read easily but another required intervention from SanDisk, but it was eventually read.
Bill Biggart's photos from 9/11 survived the collapse of the second tower on a CompactFlash microdrive card.
Recovery
If you suspect a card may be getting flakey, or if you run into trouble reading a card, immediately create a backup of everything on the card. There are low-level recovery tools like TestDisk and PhotoRec that come in handy for this.
Don't store them below -40 °C or above +100 °C (for example, a car dashboard in some places).
You can theoretically damage them with a severe enough impact. 2000 g or more might be enough.
Don't short the pins, or use them in space. Don't use them for long term archival purposes - in 500 years several of the compounds will have started degrading and no-one will know how to read them any more.
Aside from that, I think it will take substantial physical damage to lose data in storage.
I don't know if this will help, but...
We use µSD cards for the entire filesystem on an embedded device, so they see reads and writes for logging purposes as well as swap. It is a journalled filesystem (previous teams' decision) and I have seen a handful of failures in a population of say 200 devices, with some brands having more failures than others. Some are complete catastrophic failures, I can't read nor re-partition and re-format the card and some are simply filesystem corruption and a re-partition and re-write has them working again. We don't trust those to be sent into the field however.
They have only been in the field for a maximum of 3 years. Thank goodness the real information has already been sent to a database and stored.
I've used several brands of SD cards in raspberry pi computers, and they usually start seeing memory corruption after a continuous uptime of anywhere between 1 to 3 months, larger SD cards seem to last longer, smaller SD cards wear out in just a couple of weeks.
Thank you for your interest in this question. Because it has attracted low-quality or spam answers that had to be removed, posting an answer now requires 10 reputation on this site (the association bonus does not count).
Would you like to answer one of these unanswered questions instead?
Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.
By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.
Already on GitHub? Sign in to your account
@@ -61,5 +61,6 @@ const char * const debugModeNames[DEBUG_COUNT] = { | |
'LIDAR_TF', | |
'CORE_TEMP', | |
'RUNAWAY_TAKEOFF', | |
'SDIO', | |
'CURRENT_SENSOR', | |
}; |
@@ -79,6 +79,7 @@ typedef enum { | |
DEBUG_LIDAR_TF, | |
DEBUG_CORE_TEMP, | |
DEBUG_RUNAWAY_TAKEOFF, | |
DEBUG_SDIO, | |
DEBUG_CURRENT, | |
DEBUG_COUNT | |
} debugType_e; |
@@ -13,6 +13,9 @@ | |
* | |
* You should have received a copy of the GNU General Public License | |
* along with Cleanflight. If not, see <http://www.gnu.org/licenses/>. | |
* | |
* Adaptation of original driver to SDIO: Chris Hockuba (https://github.com/conkerkh) | |
* | |
*/ | |
#include<stdbool.h> | |
@@ -21,6 +24,7 @@ | |
#include'platform.h' | |
#defineUSE_SDCARD_SDIO | |
#ifdef USE_SDCARD_SDIO | |
#include'drivers/nvic.h' | |
@@ -32,7 +36,7 @@ | |
#include'drivers/sdcard.h' | |
#include'drivers/sdcard_standard.h' | |
#include'drivers/sdio_stdlib.h' | |
#include'drivers/sdmmc_sdio.h' | |
#ifdef AFATFS_USE_INTROSPECTIVE_LOGGING | |
#defineSDCARD_PROFILING | |
@@ -86,14 +90,13 @@ typedef struct sdcard_t { | |
sdcardMetadata_t metadata; | |
sdcardCSD_t csd; | |
#ifdef SDIO_DMA | |
volatileuint8_t TxDMA_Cplt; | |
volatileuint8_t RxDMA_Cplt; | |
#endif | |
#ifdef SDCARD_PROFILING | |
sdcard_profilerCallback_c profiler; | |
#endif | |
bool enabled; | |
IO_t cardDetectPin; | |
dmaIdentifier_e dma; | |
uint8_t dmaChannel; | |
} sdcard_t; | |
staticsdcard_t sdcard; | |
@@ -102,22 +105,30 @@ STATIC_ASSERT(sizeof(sdcardCSD_t) 16, sdcard_csd_bitfields_didnt_pack_properl | |
voidsdcardInsertionDetectDeinit(void) | |
{ | |
//Handled by the driver | |
return; | |
if (sdcard.cardDetectPin) { | |
IOInit(sdcard.cardDetectPin, OWNER_FREE, 0); | |
IOConfigGPIO(sdcard.cardDetectPin, IOCFG_IN_FLOATING); | |
} | |
} | |
voidsdcardInsertionDetectInit(void) | |
{ | |
//Handled by the driver | |
return; | |
if (sdcard.cardDetectPin) { | |
IOInit(sdcard.cardDetectPin, OWNER_SDCARD_DETECT, 0); | |
IOConfigGPIO(sdcard.cardDetectPin, IOCFG_IPU); | |
} | |
} | |
/** | |
* Detect if a SD card is physically present in the memory slot. | |
*/ | |
boolsdcard_isInserted(void) | |
{ | |
returnSD_Detect(); | |
bool ret = true; | |
if (sdcard.cardDetectPin) { | |
ret = IORead(sdcard.cardDetectPin) 0; | |
} | |
return ret; | |
} | |
/** | |
@@ -137,16 +148,14 @@ bool sdcard_isFunctional(void) | |
*/ | |
staticvoidsdcard_reset(void) | |
{ | |
SD_DeInit(); | |
delay(200); | |
SD_Init(); | |
sdcard.failureCount++; | |
if (sdcard.failureCount >= SDCARD_MAX_CONSECUTIVE_FAILURES || sdcard_isInserted() SD_NOT_PRESENT) { | |
sdcard.state = SDCARD_STATE_NOT_PRESENT; | |
} else { | |
sdcard.operationStartTime = millis(); | |
sdcard.state = SDCARD_STATE_RESET; | |
if (SD_Init() != 0) { | |
sdcard.failureCount++; | |
if (sdcard.failureCount >= SDCARD_MAX_CONSECUTIVE_FAILURES || sdcard_isInserted() SD_NOT_PRESENT) { | |
sdcard.state = SDCARD_STATE_NOT_PRESENT; | |
} else { | |
sdcard.operationStartTime = millis(); | |
sdcard.state = SDCARD_STATE_RESET; | |
} | |
} | |
} | |
@@ -165,13 +174,13 @@ static sdcardReceiveBlockStatus_e sdcard_receiveDataBlock(uint8_t *buffer, int c | |
{ | |
UNUSED(buffer); | |
UNUSED(count); | |
SD_Error ret = SD_WaitReadOperation(); | |
SD_Error_t ret = SD_CheckRead(); | |
if (ret SD_REQUEST_PENDING) { | |
if (ret SD_BUSY) { | |
return SDCARD_RECEIVE_BLOCK_IN_PROGRESS; | |
} | |
if (SD_GetStatus() != SD_TRANSFER_OK) { | |
if (SD_GetState() != true) { | |
return SDCARD_RECEIVE_ERROR; | |
} | |
@@ -180,21 +189,24 @@ static sdcardReceiveBlockStatus_e sdcard_receiveDataBlock(uint8_t *buffer, int c | |
staticboolsdcard_receiveCID(void) | |
{ | |
SD_CardInfo sdinfo; | |
SD_GetCardInfo(&sdinfo); | |
sdcard.metadata.manufacturerID = sdinfo.SD_cid.ManufacturerID; | |
sdcard.metadata.oemID = sdinfo.SD_cid.OEM_AppliID; | |
sdcard.metadata.productName[0] = (sdinfo.SD_cid.ProdName1 & 0xFF000000) >> 24; | |
sdcard.metadata.productName[1] = (sdinfo.SD_cid.ProdName1 & 0x00FF0000) >> 16; | |
sdcard.metadata.productName[2] = (sdinfo.SD_cid.ProdName1 & 0x0000FF00) >> 8; | |
sdcard.metadata.productName[3] = (sdinfo.SD_cid.ProdName1 & 0x000000FF) >> 0; | |
sdcard.metadata.productName[4] = sdinfo.SD_cid.ProdName2; | |
sdcard.metadata.productRevisionMajor = sdinfo.SD_cid.ProdRev >> 4; | |
sdcard.metadata.productRevisionMinor = sdinfo.SD_cid.ProdRev & 0x0F; | |
sdcard.metadata.productSerial = sdinfo.SD_cid.ProdSN; | |
sdcard.metadata.productionYear = (((sdinfo.SD_cid.ManufactDate & 0x0F00) >> 8) | ((sdinfo.SD_cid.ManufactDate & 0xFF) >> 4)) + 2000; | |
sdcard.metadata.productionMonth = sdinfo.SD_cid.ManufactDate & 0x000F; | |
SD_CardInfo_t *sdinfo = &SD_CardInfo; | |
SD_Error_t error = SD_GetCardInfo(); | |
if (error) { | |
returnfalse; | |
} | |
sdcard.metadata.manufacturerID = sdinfo->SD_cid.ManufacturerID; | |
sdcard.metadata.oemID = sdinfo->SD_cid.OEM_AppliID; | |
sdcard.metadata.productName[0] = (sdinfo->SD_cid.ProdName1 & 0xFF000000) >> 24; | |
sdcard.metadata.productName[1] = (sdinfo->SD_cid.ProdName1 & 0x00FF0000) >> 16; | |
sdcard.metadata.productName[2] = (sdinfo->SD_cid.ProdName1 & 0x0000FF00) >> 8; | |
sdcard.metadata.productName[3] = (sdinfo->SD_cid.ProdName1 & 0x000000FF) >> 0; | |
sdcard.metadata.productName[4] = sdinfo->SD_cid.ProdName2; | |
sdcard.metadata.productRevisionMajor = sdinfo->SD_cid.ProdRev >> 4; | |
sdcard.metadata.productRevisionMinor = sdinfo->SD_cid.ProdRev & 0x0F; | |
sdcard.metadata.productSerial = sdinfo->SD_cid.ProdSN; | |
sdcard.metadata.productionYear = (((sdinfo->SD_cid.ManufactDate & 0x0F00) >> 8) | ((sdinfo->SD_cid.ManufactDate & 0xFF) >> 4)) + 2000; | |
sdcard.metadata.productionMonth = sdinfo->SD_cid.ManufactDate & 0x000F; | |
returntrue; | |
} | |
@@ -204,11 +216,15 @@ static bool sdcard_fetchCSD(void) | |
/* The CSD command's data block should always arrive within 8 idle clock cycles (SD card spec). This is because | |
* the information about card latency is stored in the CSD register itself, so we can't use that yet! | |
*/ | |
SD_CardInfo sdinfo; | |
SD_GetCardInfo(&sdinfo); | |
SD_CardInfo_t *sdinfo = &SD_CardInfo; | |
SD_Error_t error; | |
error = SD_GetCardInfo(); | |
if (error) { | |
returnfalse; | |
} | |
sdcard.metadata.numBlocks = sdinfo.CardCapacity / sdinfo.CardBlockSize; | |
return(bool) 1; | |
sdcard.metadata.numBlocks = sdinfo->CardCapacity; | |
returntrue; | |
} | |
/** | |
@@ -218,28 +234,42 @@ static bool sdcard_fetchCSD(void) | |
*/ | |
staticboolsdcard_checkInitDone(void) | |
{ | |
uint8_t ret = SD_GetStatus(); | |
if (SD_GetState()) { | |
SD_CardType_t *sdtype = &SD_CardType; | |
SD_GetCardInfo(); | |
if (ret SD_TRANSFER_OK) { | |
SD_CardInfo sdinfo; | |
SD_GetCardInfo(&sdinfo); | |
sdcard.version = (sdinfo.CardType) ? 2 : 1; | |
sdcard.highCapacity = (sdinfo.CardType2) ? 1 : 0; | |
sdcard.version = (*sdtype) ? 2 : 1; | |
sdcard.highCapacity = (*sdtype 2) ? 1 : 0; | |
returntrue; | |
} | |
// When card init is complete, the idle bit in the response becomes zero. | |
return(ret SD_TRANSFER_OK) ? true : false; | |
returnfalse; | |
} | |
/** | |
* Begin the initialization process for the SD card. This must be called first before any other sdcard_ routine. | |
*/ | |
voidsdcard_init(const sdcardConfig_t *config) | |
{ | |
UNUSED(config); | |
if (SD_Detect() SD_PRESENT) { | |
if (SD_Init() != SD_OK) { | |
sdcard.enabled = config->enabled; | |
if (!sdcard.enabled) { | |
sdcard.state = SDCARD_STATE_NOT_PRESENT; | |
return; | |
} | |
sdcard.dma = config->dmaIdentifier; | |
if (sdcard.dma0) { | |
sdcard.state = SDCARD_STATE_NOT_PRESENT; | |
return; | |
} | |
if (config->cardDetectTag) { | |
sdcard.cardDetectPin = IOGetByTag(config->cardDetectTag); | |
} else { | |
sdcard.cardDetectPin = IO_NONE; | |
} | |
SD_Initialize_LL(dmaGetRefByIdentifier(sdcard.dma)); | |
if (SD_IsDetected()) { | |
if (SD_Init() != 0) { | |
sdcard.state = SDCARD_STATE_NOT_PRESENT; | |
sdcard.failureCount++; | |
return; | |
@@ -280,7 +310,7 @@ static sdcardOperationStatus_e sdcard_endWriteBlocks() | |
// 8 dummy clocks to guarantee N_WR clocks between the last card response and this token | |
// Card may choose to raise a busy (non-0xFF) signal after at most N_BR (1 byte) delay | |
if (SD_GetStatus() SD_TRANSFER_OK) { | |
if (SD_GetState()) { | |
sdcard.state = SDCARD_STATE_READY; | |
return SDCARD_OPERATION_SUCCESS; | |
} else { | |
@@ -297,8 +327,10 @@ static sdcardOperationStatus_e sdcard_endWriteBlocks() | |
*/ | |
boolsdcard_poll(void) | |
{ | |
uint8_t initStatus; | |
UNUSED(initStatus); | |
if (!sdcard.enabled) { | |
sdcard.state = SDCARD_STATE_NOT_PRESENT; | |
returnfalse; | |
} | |
#ifdef SDCARD_PROFILING | |
bool profilingComplete; | |
@@ -343,7 +375,7 @@ bool sdcard_poll(void) | |
break; | |
case SDCARD_STATE_SENDING_WRITE: | |
// Have we finished sending the write yet? | |
if (SD_WaitWriteOperation() SD_OK) { | |
if (SD_CheckWrite() SD_OK) { | |
// The SD card is now busy committing that write to the card | |
sdcard.state = SDCARD_STATE_WAITING_FOR_WRITE; | |
@@ -356,7 +388,7 @@ bool sdcard_poll(void) | |
} | |
break; | |
case SDCARD_STATE_WAITING_FOR_WRITE: | |
if (SD_GetStatus() SD_TRANSFER_OK) { | |
if (SD_GetState()) { | |
#ifdef SDCARD_PROFILING | |
profilingComplete = true; | |
#endif | |
@@ -370,7 +402,7 @@ bool sdcard_poll(void) | |
sdcard.state = SDCARD_STATE_WRITING_MULTIPLE_BLOCKS; | |
} elseif (sdcard.multiWriteBlocksRemain1) { | |
// This function changes the sd card state for us whether immediately succesful or delayed: | |
sdcard.multiWriteBlocksRemain = 0; | |
sdcard_endWriteBlocks(); | |
} else { | |
sdcard.state = SDCARD_STATE_READY; | |
} | |
@@ -424,7 +456,7 @@ bool sdcard_poll(void) | |
} | |
break; | |
case SDCARD_STATE_STOPPING_MULTIPLE_BLOCK_WRITE: | |
if (SD_GetStatus() SD_TRANSFER_OK) { | |
if (SD_GetState()) { | |
sdcard.state = SDCARD_STATE_READY; | |
#ifdef SDCARD_PROFILING | |
@@ -500,7 +532,8 @@ sdcardOperationStatus_e sdcard_writeBlock(uint32_t blockIndex, uint8_t *buffer, | |
sdcard.pendingOperation.chunkIndex = 1; // (for non-DMA transfers) we've sent chunk #0 already | |
sdcard.state = SDCARD_STATE_SENDING_WRITE; | |
if (SD_WriteBlock(buffer, blockIndex * 512, 1) != SD_OK) { | |
//TODO: make sure buffer is aligned | |
if (SD_WriteBlocks_DMA(blockIndex, (uint32_t*) buffer, 512, 1) != SD_OK) { | |
/* Our write was rejected! This could be due to a bad address but we hope not to attempt that, so assume | |
* the card is broken and needs reset. | |
*/ | |
@@ -544,16 +577,10 @@ sdcardOperationStatus_e sdcard_beginWriteBlocks(uint32_t blockIndex, uint32_t bl | |
} | |
} | |
// if (BSP_SD_Erase(blockIndex, blockCount * 512 + blockIndex)) { | |
sdcard.state = SDCARD_STATE_WRITING_MULTIPLE_BLOCKS; | |
sdcard.multiWriteBlocksRemain = blockCount; | |
sdcard.multiWriteNextBlock = blockIndex; | |
// Leave the card selected | |
return SDCARD_OPERATION_SUCCESS; | |
// } else { | |
// sdcard_reset(); | |
// return SDCARD_OPERATION_FAILURE; | |
// } | |
sdcard.state = SDCARD_STATE_WRITING_MULTIPLE_BLOCKS; | |
sdcard.multiWriteBlocksRemain = blockCount; | |
sdcard.multiWriteNextBlock = blockIndex; | |
return SDCARD_OPERATION_SUCCESS; | |
} | |
/** | |
@@ -571,15 +598,21 @@ sdcardOperationStatus_e sdcard_beginWriteBlocks(uint32_t blockIndex, uint32_t bl | |
boolsdcard_readBlock(uint32_t blockIndex, uint8_t *buffer, sdcard_operationCompleteCallback_c callback, uint32_t callbackData) | |
{ | |
if (sdcard.state != SDCARD_STATE_READY) { | |
returnfalse; | |
if (sdcard.state SDCARD_STATE_WRITING_MULTIPLE_BLOCKS) { | |
if (sdcard_endWriteBlocks() != SDCARD_OPERATION_SUCCESS) { | |
returnfalse; | |
} | |
} else { | |
returnfalse; | |
} | |
} | |
#ifdef SDCARD_PROFILING | |
sdcard.pendingOperation.profileStartTime = micros(); | |
#endif | |
// Standard size cards use byte addressing, high capacity cards use block addressing | |
uint8_t status = SD_ReadBlock(buffer, blockIndex *512, 1); | |
uint8_t status = SD_ReadBlocks_DMA(blockIndex, (uint32_t*) buffer,512, 1); | |
if (status SD_OK) { | |
sdcard.pendingOperation.buffer = buffer; |
'My SD card becomes unavailable, as Windows prompts the error message constantly saying the card is write protected. Now I can neither copy files to the card nor format it. Does anyone know how to disable write protection and format the write-protected SD card so that it can get back to normal again?'
Once a hard drive, memory card or USB flash drive is write-protected, it means that you can no longer use the storage devices like before. Any operation on it will be rejected. For example, if you suddenly find that your SD card is set to write protection, you cannot write any new data to the card or delete files on it or format it. Then SD card in this situation becomes useless and has no further use. To troubleshoot such an issue, first, you should learn how to get rid of SD card write protection.
It's critical to erase a write-protected SD card and make it functional again. Following are three methods. Hope at least one of them echoes your case so that you can move on to the next part learning how to format the SD card.
Is there a small switch on its side? Change the position should turn off the write protection and let you change the content.
Go to My Computer and look for your card reader under Devices with Removable Storage, then right-click on it and click 'Properties'. In the pop-up box, sometimes there's an option to remove write-protection. Change the status of this option and try again.
Now things get easy after we erase the write protection on the SD card. To format the memory card, we introduce a very user-friendly utility - EaseUS Partition Master Free, the powerful free partition manager that will help you out with simple steps.
Step 1: Launch EaseUS Partition Master, right-click the partition on your external hard drive/USB/SD card which you want to format and choose the 'Format' option.
Step 2: Assign a new partition label, file system (NTFS/FAT32/EXT2/EXT3), and cluster size to the selected partition, then click 'OK'.
Step 3: In the Warning window, click 'OK' to continue.
Step 4: Click the 'Execute Operation' button in the top-left corner to review the changes, then click 'Apply' to start formatting your external hard drive/USB/SD card.
After the operation, you can also use the magic partition software to resize partitions.