kalidomra / adamnet-drive-emulator Goto Github PK

Setting ‘const unsigned int namelength =’ to less than 41 locks the ADE up on boot. Setting it between 41 and 71 will lock the ADE when scrolling through files. Higher the setting will require more scrolling to lock up the ADE. This appears to be a carryover from v0.6 as well.

Thank you for sharing this project. I was able to replicate it and it worked great.

One thing you might want to update on the README is that you must use v1 of the SD Card Library (https://github.com/greiman/SdFat/tree/1.1.4), not the latest version. If you try using the latest version (which was 2.0.4 when I wrote this), you will get the following compiler error:

C:\Users\heiro\OneDrive\Arduino\AdamNet_Drive_Emulator\DeviceSetup.ino: In function 'void DeviceSetup()':
DeviceSetup:105:50: error: no matching function for call to 'SdFat32::chdir(const char*, bool)'
       dirtest = sd.chdir(BootDiskDir.c_str(),true);
                                                  ^
In file included from C:\Users\heiro\Documents\Arduino\libraries\SdFat-2.0.4\src/FatLib/FatLib.h:27:0,
                 from C:\Users\heiro\Documents\Arduino\libraries\SdFat-2.0.4\src/SdFat.h:34,
                 from C:\Users\heiro\OneDrive\Arduino\AdamNet_Drive_Emulator\AdamNet_Drive_Emulator.ino:4:
C:\Users\heiro\Documents\Arduino\libraries\SdFat-2.0.4\src/FatLib/FatVolume.h:66:8: note: candidate: bool FatVolume::chdir()
   bool chdir() {
        ^~~~~
C:\Users\heiro\Documents\Arduino\libraries\SdFat-2.0.4\src/FatLib/FatVolume.h:66:8: note:   candidate expects 0 arguments, 2 provided
C:\Users\heiro\Documents\Arduino\libraries\SdFat-2.0.4\src/FatLib/FatVolume.h:75:8: note: candidate: bool FatVolume::chdir(const char*)
   bool chdir(const char *path);
        ^~~~~
C:\Users\heiro\Documents\Arduino\libraries\SdFat-2.0.4\src/FatLib/FatVolume.h:75:8: note:   candidate expects 1 argument, 2 provided
C:\Users\heiro\Documents\Arduino\libraries\SdFat-2.0.4\src/FatLib/FatVolume.h:250:8: note: candidate: bool FatVolume::chdir(const String&)
   bool chdir(const String& path) {
        ^~~~~
C:\Users\heiro\Documents\Arduino\libraries\SdFat-2.0.4\src/FatLib/FatVolume.h:250:8: note:   candidate expects 1 argument, 2 provided
C:\Users\heiro\OneDrive\Arduino\AdamNet_Drive_Emulator\DeviceSetup.ino: In function 'void DeviceSetupCommand(byte)':
DeviceSetup:159:52: error: no matching function for call to 'SdFat32::chdir(const char*, bool)'
   boolean dirtest = sd.chdir(eepromdir.c_str(),true);
                                                    ^
...

See greiman/SdFat#222 for more details.

Thanks again for sharing this awesome project!

It looks like at some point you shifted from capacitive touch to tactile buttons. I was just wondering if this was for a technical reason, or because of the convenience of the tactile buttons included on many LCD shields?

I'm considering using capacitive touch as a way of lowering costs and reducing moving parts, if the OLED option materializes - and maybe even if it doesn't.

This also lets me create a generic LCD shield with capacitive touch that would look really nice for use on standard ATmega boards too.

(I've been waiting for boards for ages but some prototype boards just came in so I am back on the case!)

The ability to remember last file loaded and have it default back to it after reset/power on to know where you left off the last time would be nice. Same functionality as the VDD. They save a text file on the SD card with the last loaded file.

Some cheaper Arduino clones use poor quality resonators. This can cause read errors on AdamNet, due to the bit bang timing being off. The Motorola 6801 that is used in the Adam is able to tolerate up to 3.5% difference in serial communication speed.

Re-work the LCD write command so that it will not corrupt a non-ADE drive. Move the refresh byte from data3 to data1. This will allow the Adam to send the write to block 0XF400FFFF. This will be out of range for any real drive. The LCD refresh would then be 0xF401FFFF.

Analog buttons still enabled during boot when using digital buttons and intermittently causing unit to falsely boot to config mode on power up. This is an issue only when designs are based around using digital buttons. Need to add check if ‘EnableAnalogButtons = false’ variable is set to ignore analog buttons during boot when checking if the select key is held down to enable config mode on boot up.

SD Command issues mounting D3 and also throwing errors in the terminal with v0.73. It has been found that the buffer needs to be zeroed out first to correct this issue.

Replace:
LoadedBlock[devicenumber-4] = 0xFFFFFFFF;

With:
BlockBuffer[devicenumber-4][0] = 0xB0 + devicenumber; // Need to zero out the buffer
BlockBuffer[devicenumber-4][1] = 0x04;
BlockBuffer[devicenumber-4][2] = 0x00;

Bug that allows same file to be mounted to multiple drives

It would be nice to have the option of turn off/on auto mounting of the boot disk for ADE variants without a DRIVE SELECT button but do have a SWAP button. A long press of the SWAP button could accomplish this.

Use the high byte of the high word on the block wanted to control the ADE from the Adam. Current list of proposed commands:
F1 - Return Current SD Card Directory: This would include an index number and the filename. There should be a limit on the filename length as 255 bytes would not be reasonable on the Adam. I propose to use 60. That would mean we could have 16 directory entries sent back per block read. So the Adam program would need to read multiple blocks to retrieve the whole directory. Read blocks F1000001, F1000002, F1000003, etc. It would not matter which device the read is issued to.
F2 - Return Currently Mounted Disk: If you read the block F2000000 on device 4, it would return the currently mounted file name in the block read.
F3 - Mount/Unmount Disk: This would mount the disk by index number. Using the lower word as the index to mount. So if you read F3000112 on device 4, the ADE would mount file 274 (112 hex) on device 4. Sending a 0 index number would unmount.
F4 - Write to LCD: This is a write command. Load the block with 32 bytes of ascii text and send this as a write. The ADE will then display the text on the LCD. It would not matter which device the write is issued to.
FA - Format: This would format the device. This would be an alternative to the existing FACE. This is required so we can disable the original FACE support and use that block without a risk of format.

Would it be possible to add support for a rotary encoder? This would allow quick and intuitive scrolling through the mountable images list far more quickly than pressing up and down buttons - especially when there are several tens or 100s of images. People intuitively know where most of their images are, and can quickly scroll to them - far faster than pressing a button 10s or 100s of times.

There are standard Arduino rotary encoders that would cheaply and elegantly fit this project.

I am interested in using the KY-040 or similar. Would you be interested in supporting this?

Add the ability to change button scan times based on both digital and analog button settings. Maybe have this ability tied to the ‘EnableAnalogButtons = false/true’ variable adjustment.

Analog buttons seem to work best with a setting of ButtonDelay >= 150 and digital buttons seem to work best with a setting of ButtonDelay >= 120.

Read error during boot of ADAMCalc. Was not an issue with first beta. Reloaded original beta and confirmed it does load fine on two separate ADAM consoles. Something changed?

This would reset the Adam when the ADE finishes all of the setup. It would require that the reset line from the AdamNet connect be attached to a pin on the Arduino. The benefit to this would be that if a boot disk is defined, one button press would re-mount the boot disk and reset the Adam. A variable in the configuration section should allow this to be disabled.

Some users are experiencing bounce issues with buttons causing issues. This is especially noticeable when scrolling through the image file list and is causing images to be skipped and not displayed.

The ability to use the mount key also as the unmount key will reduce keys required and simplify things. Same functionality as the VDD.

Add the option in code to not use the analog switch input AD0 line and use dedicated digital I/O lines (selectable lines in code like for the activity indicator lines) for individual switches instead? This would come in handy for people who want to make custom projects and avoid dealing with possible resistor tolerance issues with using analog. Each line pulled low and detected with logical high with switch closure.

Would it be nice to have an activity LED flash when drives are reading or writing. Large loads keep you wondering if anything is happening.

It might be nice (and easy) to add support for a second SD card. This might be implemented with a separate SPI port, or shared SPI port and second select line.

It would make copying SD cards much easier without a PC. It would just require a second SD shield.

This would automatically mount the designated file on an ADE reset. It would ignore any previously mounted files if the mount file was present. The file name will default to boot.dsk, but can be changed in the configuration section.

When switching to the enhanced mode on a read to block 0XDEADBEEF, send the status of the ADE. This could include the firmware version also. This would enable the Adam to detect when an ADE is connected and not another device.

For the boot image to automatically boot it has to be all lowercase in order to work, including the extension. Add the ability to make it not case sensitive to make it less confusing.

Would it be possible (since the ADAMNet allows every device to snoop every other) that is the keyboard typed an unlikely Hayes-like command (eg: +++ after a three second gap) further typing could be read by the ADE to filter the disk image list down to one or very few images?

Now that ADE Commander has full control of enabling / disabling any combination of drives (D1-D4), it would probably be best to change the current behavior of the SWAP button when held down during boot. It currently will disable D2 for use when a physical drive is used and holding again will enable all drives to a known usable state in case all drives are disable on ADE variants without a display.

It would now probably be best to have all drives disabled now to quickly and easily simulate the ADE not on ADAMnet and holding again will enable all drives. Any other combination can be done through ADE Commander.

The following setup() changes have been tested

if (InitialKeypress == 6){ // Swap Button Held - All devices disabled (simulates ADE being removed from ADAMnet)
// If Device 5 is already disabled, all devices enabled
if (EEPROM.read(5) == 1){
Serial.println(F("Disabling all Devices"));
EEPROM.write(4,0); // Disable Device 4
EEPROM.write(5,0); // Disable Device 5
EEPROM.write(6,0); // Disable Device 6
EEPROM.write(7,0); // Disable Device 7
}
else if (EEPROM.read(5) == 0){ // Enable all Devices for normal operation and correct any config errors that could make devices lost for good.
Serial.println(F("Enabling all Devices"));
EEPROM.write(4,1); // Enable Device 4
EEPROM.write(5,1); // Enable Device 5
EEPROM.write(6,1); // Enable Device 6
EEPROM.write(7,1); // Enable Device 7
}
}

It would be nice if users with an existing install of ADE could copy an update onto their SD card, and on start-up the ATmega could check the SD card for an update and import it then reset if one is present. This would allow a lot of users not comfortable with using the Arduino IDE to more easily keep their systems current.

This is also very easy to implement.

I am trying to compile the source code and I get the following errors. I installed the SdFAT library. Is there another library that needs to be installed? I am using Arduino 1.8.13. I know I can just download the compiled binaries but I wish to compile it myself.

Arduino: 1.8.13 (Linux), Board: "Arduino Mega or Mega 2560, ATmega2560 (Mega 2560)"

/home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/DeviceSetup.ino: In function 'void DeviceSetup()':
DeviceSetup:105:50: error: no matching function for call to 'SdFat32::chdir(const char*, bool)'
dirtest = sd.chdir(BootDiskDir.c_str(),true);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate: bool FatVolume::chdir()
bool chdir() {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate expects 0 arguments, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate: bool FatVolume::chdir(const char*)
bool chdir(const char path);
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate expects 1 argument, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate: bool FatVolume::chdir(const String&)
bool chdir(const String& path) {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate expects 1 argument, 2 provided
/home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/DeviceSetup.ino: In function 'void DeviceSetupCommand(byte)':
DeviceSetup:159:52: error: no matching function for call to 'SdFat32::chdir(const char, bool)'
boolean dirtest = sd.chdir(eepromdir.c_str(),true);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate: bool FatVolume::chdir()
bool chdir() {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate expects 0 arguments, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate: bool FatVolume::chdir(const char*)
bool chdir(const char path);
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate expects 1 argument, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate: bool FatVolume::chdir(const String&)
bool chdir(const String& path) {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate expects 1 argument, 2 provided
/home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/FACECommand.ino: In function 'void FACECommand(byte)':
FACECommand:13:34: error: no matching function for call to 'SdFat32::chdir(const char, bool)'
sd.chdir(filedir.c_str(),true);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate: bool FatVolume::chdir()
bool chdir() {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate expects 0 arguments, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate: bool FatVolume::chdir(const char*)
bool chdir(const char path);
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate expects 1 argument, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate: bool FatVolume::chdir(const String&)
bool chdir(const String& path) {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate expects 1 argument, 2 provided
FACECommand:14:22: error: 'FatFile FatVolume::vwd()' is private within this context
file.open(sd.vwd(),fileindexnumber, O_READ | O_WRITE);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:336:12: note: declared private here
FatFile* vwd() {return &m_vwd;}
^~~
/home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/GetFileName.ino: In function 'String GetFileName(unsigned int, byte)':
GetFileName:16:36: error: 'FatFile* FatVolume::vwd()' is private within this context
byte opentest = file.open(sd.vwd(),FilesIndex[IncomingFileIndex], O_READ);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:336:12: note: declared private here
FatFile* vwd() {return &m_vwd;}
^~~
/home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/GetFileNumber.ino: In function 'unsigned int GetFileNumber(unsigned int, String, String)':
GetFileNumber:8:36: error: no matching function for call to 'SdFat32::chdir(const char*, bool)'
sd.chdir(IncomingDir.c_str(),true); // Change to the directory
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate: bool FatVolume::chdir()
bool chdir() {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate expects 0 arguments, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate: bool FatVolume::chdir(const char*)
bool chdir(const char path);
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate expects 1 argument, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate: bool FatVolume::chdir(const String&)
bool chdir(const String& path) {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate expects 1 argument, 2 provided
GetFileNumber:9:31: error: 'FatFile FatVolume::vwd()' is private within this context
while (file.openNext(sd.vwd(), O_READ)) { // Loop through the directory
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:336:12: note: declared private here
FatFile* vwd() {return &m_vwd;}
^~~
/home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/LCDRefresh.ino: In function 'void LCDRefresh()':
LCDRefresh:12:45: error: no matching function for call to 'SdFat32::chdir(const char*, bool)'
sd.chdir(CurrentDirectory.c_str(),true);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate: bool FatVolume::chdir()
bool chdir() {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate expects 0 arguments, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate: bool FatVolume::chdir(const char*)
bool chdir(const char path);
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate expects 1 argument, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate: bool FatVolume::chdir(const String&)
bool chdir(const String& path) {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate expects 1 argument, 2 provided
LCDRefresh:33:43: error: no matching function for call to 'SdFat32::chdir(const char, bool)'
sd.chdir(CurrentDirectory.c_str(),true);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate: bool FatVolume::chdir()
bool chdir() {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate expects 0 arguments, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate: bool FatVolume::chdir(const char*)
bool chdir(const char path);
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate expects 1 argument, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate: bool FatVolume::chdir(const String&)
bool chdir(const String& path) {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate expects 1 argument, 2 provided
/home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/ProcessKeys.ino: In function 'void ProcessKeys()':
ProcessKeys:4:43: error: no matching function for call to 'SdFat32::chdir(const char, bool)'
sd.chdir(CurrentDirectory.c_str(),true);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate: bool FatVolume::chdir()
bool chdir() {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate expects 0 arguments, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate: bool FatVolume::chdir(const char*)
bool chdir(const char path);
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate expects 1 argument, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate: bool FatVolume::chdir(const String&)
bool chdir(const String& path) {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate expects 1 argument, 2 provided
ProcessKeys:28:46: error: no matching function for call to 'SdFat32::chdir(const char, bool)'
sd.chdir(CurrentDirectory.c_str(),true);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate: bool FatVolume::chdir()
bool chdir() {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate expects 0 arguments, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate: bool FatVolume::chdir(const char*)
bool chdir(const char path);
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate expects 1 argument, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate: bool FatVolume::chdir(const String&)
bool chdir(const String& path) {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate expects 1 argument, 2 provided
ProcessKeys:52:45: error: no matching function for call to 'SdFat32::chdir(const char, bool)'
sd.chdir(CurrentDirectory.c_str(),true);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate: bool FatVolume::chdir()
bool chdir() {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate expects 0 arguments, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate: bool FatVolume::chdir(const char*)
bool chdir(const char path);
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate expects 1 argument, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate: bool FatVolume::chdir(const String&)
bool chdir(const String& path) {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate expects 1 argument, 2 provided
ProcessKeys:74:45: error: no matching function for call to 'SdFat32::chdir(const char, bool)'
sd.chdir(CurrentDirectory.c_str(),true);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate: bool FatVolume::chdir()
bool chdir() {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate expects 0 arguments, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate: bool FatVolume::chdir(const char*)
bool chdir(const char path);
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate expects 1 argument, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate: bool FatVolume::chdir(const String&)
bool chdir(const String& path) {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate expects 1 argument, 2 provided
ProcessKeys:133:43: error: no matching function for call to 'SdFat32::chdir(const char, bool)'
sd.chdir(CurrentDirectory.c_str(),true);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate: bool FatVolume::chdir()
bool chdir() {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate expects 0 arguments, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate: bool FatVolume::chdir(const char*)
bool chdir(const char path);
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate expects 1 argument, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate: bool FatVolume::chdir(const String&)
bool chdir(const String& path) {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate expects 1 argument, 2 provided
ProcessKeys:149:43: error: no matching function for call to 'SdFat32::chdir(const char, bool)'
sd.chdir(CurrentDirectory.c_str(),true);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate: bool FatVolume::chdir()
bool chdir() {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate expects 0 arguments, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate: bool FatVolume::chdir(const char*)
bool chdir(const char path);
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate expects 1 argument, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate: bool FatVolume::chdir(const String&)
bool chdir(const String& path) {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate expects 1 argument, 2 provided
/home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/SDCardGetDir.ino: In function 'void SDCardGetDir(int)':
SDCardGetDir:20:59: error: 'FatFile FatVolume::vwd()' is private within this context
while (NumberofFiles < MaxFiles && file.openNext(sd.vwd(), O_READ)) {
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:336:12: note: declared private here
FatFile* vwd() {return &m_vwd;}
^~~
SDCardGetDir:65:42: error: 'FatFile* FatVolume::vwd()' is private within this context
bool lastfile = file.openNext(sd.vwd(), O_READ); // Are there any more files?
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:336:12: note: declared private here
FatFile* vwd() {return &m_vwd;}
^~~
/home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/SDCardSetup.ino: In function 'void SDCardSetup()':
SDCardSetup:11:41: error: no matching function for call to 'SdFat32::chdir(const char*, bool)'
sd.chdir(CurrentDirectory.c_str(),true);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate: bool FatVolume::chdir()
bool chdir() {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate expects 0 arguments, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate: bool FatVolume::chdir(const char*)
bool chdir(const char path);
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate expects 1 argument, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate: bool FatVolume::chdir(const String&)
bool chdir(const String& path) {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate expects 1 argument, 2 provided
/home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/SDCommand.ino: In function 'void CurrentDirectoryReturn(byte)':
SDCommand:84:41: error: no matching function for call to 'SdFat32::chdir(const char, bool)'
sd.chdir(CurrentDirectory.c_str(),true);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate: bool FatVolume::chdir()
bool chdir() {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate expects 0 arguments, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate: bool FatVolume::chdir(const char*)
bool chdir(const char path);
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate expects 1 argument, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate: bool FatVolume::chdir(const String&)
bool chdir(const String& path) {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate expects 1 argument, 2 provided
/home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/SDCommand.ino: In function 'void MountUnmount(byte)':
SDCommand:185:41: error: no matching function for call to 'SdFat32::chdir(const char, bool)'
sd.chdir(CurrentDirectory.c_str(),true);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate: bool FatVolume::chdir()
bool chdir() {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate expects 0 arguments, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate: bool FatVolume::chdir(const char*)
bool chdir(const char path);
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate expects 1 argument, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate: bool FatVolume::chdir(const String&)
bool chdir(const String& path) {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate expects 1 argument, 2 provided
SDCommand:233:43: error: no matching function for call to 'SdFat32::chdir(const char, bool)'
sd.chdir(CurrentDirectory.c_str(),true);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate: bool FatVolume::chdir()
bool chdir() {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate expects 0 arguments, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate: bool FatVolume::chdir(const char*)
bool chdir(const char path);
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate expects 1 argument, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate: bool FatVolume::chdir(const String&)
bool chdir(const String& path) {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate expects 1 argument, 2 provided
SDCommand:241:43: error: no matching function for call to 'SdFat32::chdir(const char, bool)'
sd.chdir(CurrentDirectory.c_str(),true);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate: bool FatVolume::chdir()
bool chdir() {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate expects 0 arguments, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate: bool FatVolume::chdir(const char*)
bool chdir(const char path);
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate expects 1 argument, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate: bool FatVolume::chdir(const String&)
bool chdir(const String& path) {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate expects 1 argument, 2 provided
SDCommand:255:43: error: no matching function for call to 'SdFat32::chdir(const char, bool)'
sd.chdir(CurrentDirectory.c_str(),true);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate: bool FatVolume::chdir()
bool chdir() {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate expects 0 arguments, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate: bool FatVolume::chdir(const char*)
bool chdir(const char path);
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate expects 1 argument, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate: bool FatVolume::chdir(const String&)
bool chdir(const String& path) {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate expects 1 argument, 2 provided
/home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/SDCommand.ino: In function 'void Delete(byte)':
SDCommand:340:43: error: no matching function for call to 'SdFat32::chdir(const char, bool)'
sd.chdir(CurrentDirectory.c_str(),true);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate: bool FatVolume::chdir()
bool chdir() {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate expects 0 arguments, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate: bool FatVolume::chdir(const char*)
bool chdir(const char path);
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate expects 1 argument, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate: bool FatVolume::chdir(const String&)
bool chdir(const String& path) {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate expects 1 argument, 2 provided
SDCommand:359:45: error: no matching function for call to 'SdFat32::chdir(const char, bool)'
sd.chdir(CurrentDirectory.c_str(),true);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate: bool FatVolume::chdir()
bool chdir() {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate expects 0 arguments, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate: bool FatVolume::chdir(const char*)
bool chdir(const char path);
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate expects 1 argument, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate: bool FatVolume::chdir(const String&)
bool chdir(const String& path) {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate expects 1 argument, 2 provided
SDCommand:362:14: error: 'FatFile FatVolume::vwd()' is private within this context
sd.vwd()->rmRfStar();
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:336:12: note: declared private here
FatFile* vwd() {return &m_vwd;}
^~~
SDCommand:364:45: error: no matching function for call to 'SdFat32::chdir(const char*, bool)'
sd.chdir(CurrentDirectory.c_str(),true);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate: bool FatVolume::chdir()
bool chdir() {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate expects 0 arguments, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate: bool FatVolume::chdir(const char*)
bool chdir(const char path);
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate expects 1 argument, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate: bool FatVolume::chdir(const String&)
bool chdir(const String& path) {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate expects 1 argument, 2 provided
SDCommand:367:45: error: no matching function for call to 'SdFat32::chdir(const char, bool)'
sd.chdir(CurrentDirectory.c_str(),true);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate: bool FatVolume::chdir()
bool chdir() {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate expects 0 arguments, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate: bool FatVolume::chdir(const char*)
bool chdir(const char path);
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate expects 1 argument, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate: bool FatVolume::chdir(const String&)
bool chdir(const String& path) {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate expects 1 argument, 2 provided
SDCommand:378:45: error: no matching function for call to 'SdFat32::chdir(const char, bool)'
sd.chdir(CurrentDirectory.c_str(),true);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate: bool FatVolume::chdir()
bool chdir() {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate expects 0 arguments, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate: bool FatVolume::chdir(const char*)
bool chdir(const char path);
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate expects 1 argument, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate: bool FatVolume::chdir(const String&)
bool chdir(const String& path) {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate expects 1 argument, 2 provided
/home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/SDCommand.ino: In function 'void NewImage(byte)':
SDCommand:518:41: error: no matching function for call to 'SdFat32::chdir(const char, bool)'
sd.chdir(CurrentDirectory.c_str(),true);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate: bool FatVolume::chdir()
bool chdir() {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate expects 0 arguments, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate: bool FatVolume::chdir(const char*)
bool chdir(const char path);
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate expects 1 argument, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate: bool FatVolume::chdir(const String&)
bool chdir(const String& path) {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate expects 1 argument, 2 provided
/home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/SDCommand.ino: In function 'void Rename(byte)':
SDCommand:621:25: error: 'FatFile FatVolume::vwd()' is private within this context
if(file.open(sd.vwd(),IndextoRename, O_READ | O_WRITE)){
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:336:12: note: declared private here
FatFile* vwd() {return &m_vwd;}
^~~
SDCommand:664:41: error: no matching function for call to 'SdFat32::chdir(const char*, bool)'
sd.chdir(CurrentDirectory.c_str(),true);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate: bool FatVolume::chdir()
bool chdir() {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate expects 0 arguments, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate: bool FatVolume::chdir(const char*)
bool chdir(const char path);
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate expects 1 argument, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate: bool FatVolume::chdir(const String&)
bool chdir(const String& path) {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate expects 1 argument, 2 provided
/home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/SDCommand.ino: In function 'void CutCopyPaste(byte)':
SDCommand:793:43: error: no matching function for call to 'SdFat32::chdir(const char, bool)'
sd.chdir(CurrentDirectory.c_str(),true);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate: bool FatVolume::chdir()
bool chdir() {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate expects 0 arguments, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate: bool FatVolume::chdir(const char*)
bool chdir(const char path);
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate expects 1 argument, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate: bool FatVolume::chdir(const String&)
bool chdir(const String& path) {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate expects 1 argument, 2 provided
/home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/SDLoadBlock.ino: In function 'int SDLoadBlock(long unsigned int, byte)':
SDLoadBlock:39:34: error: no matching function for call to 'SdFat32::chdir(const char, bool)'
sd.chdir(filedir.c_str(),true);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate: bool FatVolume::chdir()
bool chdir() {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate expects 0 arguments, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate: bool FatVolume::chdir(const char*)
bool chdir(const char path);
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate expects 1 argument, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate: bool FatVolume::chdir(const String&)
bool chdir(const String& path) {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate expects 1 argument, 2 provided
SDLoadBlock:40:41: error: 'FatFile FatVolume::vwd()' is private within this context
boolean dirtest = file.open(sd.vwd(),fileindexnumber, O_READ);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:336:12: note: declared private here
FatFile* vwd() {return &m_vwd;}
^~~
SDLoadBlock:75:34: error: no matching function for call to 'SdFat32::chdir(const char*, bool)'
sd.chdir(filedir.c_str(),true);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate: bool FatVolume::chdir()
bool chdir() {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate expects 0 arguments, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate: bool FatVolume::chdir(const char*)
bool chdir(const char path);
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate expects 1 argument, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate: bool FatVolume::chdir(const String&)
bool chdir(const String& path) {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate expects 1 argument, 2 provided
SDLoadBlock:76:41: error: 'FatFile FatVolume::vwd()' is private within this context
boolean dirtest = file.open(sd.vwd(),fileindexnumber, O_READ);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:336:12: note: declared private here
FatFile* vwd() {return &m_vwd;}
^~~
SDLoadBlock:121:36: error: no matching function for call to 'SdFat32::chdir(const char*, bool)'
sd.chdir(filedir.c_str(),true);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate: bool FatVolume::chdir()
bool chdir() {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate expects 0 arguments, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate: bool FatVolume::chdir(const char*)
bool chdir(const char path);
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate expects 1 argument, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate: bool FatVolume::chdir(const String&)
bool chdir(const String& path) {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate expects 1 argument, 2 provided
SDLoadBlock:122:43: error: 'FatFile FatVolume::vwd()' is private within this context
boolean dirtest = file.open(sd.vwd(),fileindexnumber, O_READ);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:336:12: note: declared private here
FatFile* vwd() {return &m_vwd;}
^~~
SDLoadBlock:147:36: error: no matching function for call to 'SdFat32::chdir(const char*, bool)'
sd.chdir(filedir.c_str(),true);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate: bool FatVolume::chdir()
bool chdir() {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate expects 0 arguments, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate: bool FatVolume::chdir(const char*)
bool chdir(const char path);
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate expects 1 argument, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate: bool FatVolume::chdir(const String&)
bool chdir(const String& path) {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate expects 1 argument, 2 provided
SDLoadBlock:148:43: error: 'FatFile FatVolume::vwd()' is private within this context
boolean dirtest = file.open(sd.vwd(),fileindexnumber, O_READ);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:336:12: note: declared private here
FatFile* vwd() {return &m_vwd;}
^~~
/home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/SDSaveBlock.ino: In function 'int SDSaveBlock(long unsigned int, byte)':
SDSaveBlock:17:32: error: no matching function for call to 'SdFat32::chdir(const char*, bool)'
sd.chdir(filedir.c_str(),true);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate: bool FatVolume::chdir()
bool chdir() {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:66:8: note: candidate expects 0 arguments, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate: bool FatVolume::chdir(const char*)
bool chdir(const char path);
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:75:8: note: candidate expects 1 argument, 2 provided
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate: bool FatVolume::chdir(const String&)
bool chdir(const String& path) {
^~~~~
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:250:8: note: candidate expects 1 argument, 2 provided
SDSaveBlock:18:38: error: 'FatFile FatVolume::vwd()' is private within this context
boolean dirtest = file.open(sd.vwd(),fileindexnumber, O_READ | O_WRITE);
^
In file included from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatLib.h:27:0,
from /home/william/snap/arduino/current/Arduino/libraries/SdFat/src/SdFat.h:34,
from /home/william/AIP/ADE/AdamNet-Drive-Emulator-master - v.90/AdamNet_Drive_Emulator/AdamNet_Drive_Emulator.ino:4:
/home/william/snap/arduino/current/Arduino/libraries/SdFat/src/FatLib/FatVolume.h:336:12: note: declared private here
FatFile* vwd() {return &m_vwd;}
^~~
exit status 1
no matching function for call to 'SdFat32::chdir(const char*, bool)'

This report would have more information with
"Show verbose output during compilation"
option enabled in File -> Preferences.

The FACE command is used by Adam software to fill the disk with e5 bytes. With a normal disk or tape drive this is not an issue. With larger disk image support, there is a potential to inadvertently issue the FACE command and wipe the disk.

If the Adam initiates a "soft" reset and there is a boot.dsk on the SD card, the boot.dsk it mounted and causes issues. 3 know titles that this is an issue:

• Family Feud
• Jeopardy
• Bible Jeopardy

These disks start fine and half way through the loading process initial a reset on the Adam.

When using an IDEboot PROM in expansion slot 2 the boot timing is altered and changes the TimeSinceReset value causing issues with ADE compatibility. It has been found that it is required to add an additional lower range for compatibility. Tests have show a range of 15 – 23 is required.

if (((TimeSinceReset <= 175) && (TimeSinceReset >= 153)) || ((TimeSinceReset <= 23) && (TimeSinceReset >= 15))){ // Lower range is needed for IDEboot PROM compatibility

If the Drive Select button is held on power up, jump to a drive selection menu. This would allow the user to select the drives to be turned on or off.

It would be nice to move beyond 1602 displays. Besides not being very clear, they crop off a lot of the file names. A modest OLED display based around a common chipset would be easy to support.

The killer feature is being able to have three lines of clear, high resolution text, so you can see the selected file, the file above and the file below as you scroll through the list. I think this would greatly improve usability.

If an Adam program reads at a rate and timing that the ADE is not expecting there can be I/O errors. It appears that the LCD scroll function is too slow to complete and release control back to the main AdamNet command processing function. There is also a potential that the processing of the keys could cause a similar issue. As of now, there are only 3 commercial programs that have this issue:

Arcade Action by ADAMagic
Brain Games by ADAMagic
Blind Date by ADAMagic

Blank screen on boot if no SD card is detected. Maybe add error reading SD card message to reduce confusion

Currently the ADE will support blocks from 0 to FFFF. This is 67,107,840 bytes. Add support to allow read and write up to the maximum allowed by Fat32. That would be 3FFFFF blocks. or a 4gb file.