Portenta Max Carrier User Manual

Copy
1nmcli connection show  # To find the ethernet device name ("eth0" in this case)

Copy
1nmcli conn add con-name <NtwrkName> type ethernet ifname <DevName> ipv4.method auto # Create a DHCP network. <NtwrkName> will be the custom network alias and <DevName> must be the device name found with the past command.
2
3nmcli conn up <NtwrkName> # Initiate the connection

Copy
1ping -I eth0 -c 4 arduino.cc  # ping 4 times to Arduino's webpage using ethernet

Copy
1/**
2  Purpose: This sketch connects a device to ip-api.com via Ethernet
3  and fetches IP details for the device.
4**/
5
6// Include the necessary libraries.
7#if defined(ARDUINO_PORTENTA_H7_M7)
8  #include <PortentaEthernet.h> // for Portenta H7 
9#elif defined(ARDUINO_PORTENTA_C33)
10  #include <EthernetC33.h>  // for Portenta C33
11#endif
12
13#include <Arduino_JSON.h>
14
15// Server address for ip-api.com.
16const char* server = "ip-api.com";
17
18// API endpoint path to get IP details in JSON format.
19String path = "/json/";
20
21// Ethernet client instance for the communication.
22EthernetClient client;
23
24// JSON variable to store and process the fetched data.
25JSONVar doc;
26
27// Variable to ensure we fetch data only once.
28bool dataFetched = false;
29
30void setup() {
31  // Begin serial communication at a baud rate of 115200.
32  Serial.begin(115200);
33
34  // Wait for the serial port to connect,
35  // This is necessary for boards that have native USB.
36  while (!Serial);
37
38  // Attempt to start Ethernet connection via DHCP,
39  // If DHCP failed, print a diagnostic message.
40  if (Ethernet.begin() == 0) {
41    Serial.println("- Failed to configure Ethernet using DHCP!");
42
43  }
44  printIPAddress();
45  delay(2000);
46}
47
48void loop() {
49  // Ensure we haven't fetched data already,
50  // ensure the Ethernet link is active,
51  // establish a connection to the server,
52  // compose and send the HTTP GET request.
53  if (!dataFetched) {
54    if (Ethernet.linkStatus() == LinkON) {
55      if (client.connect(server, 80)) {
56        client.print("GET ");
57        client.print(path);
58        client.println(" HTTP/1.1");
59        client.print("Host: ");
60        client.println(server);
61        client.println("Connection: close");
62        client.println();
63
64        // Wait and skip the HTTP headers to get to the JSON data.
65        char endOfHeaders[] = "\r\n\r\n";
66        client.find(endOfHeaders);
67
68        // Read and parse the JSON response.
69        String payload = client.readString();
70        doc = JSON.parse(payload);
71
72        // Check if the parsing was successful.
73        if (JSON.typeof(doc) == "undefined") {
74          Serial.println("- Parsing failed!");
75          return;
76        }
77
78        // Extract and print the IP details.
79        Serial.println("*** IP Details:");
80        Serial.print("- IP Address: ");
81        Serial.println((const char*)doc["query"]);
82        Serial.print("- City: ");
83        Serial.println((const char*)doc["city"]);
84        Serial.print("- Region: ");
85        Serial.println((const char*)doc["regionName"]);
86        Serial.print("- Country: ");
87        Serial.println((const char*)doc["country"]);
88        Serial.println("");
89
90        // Mark data as fetched.
91        dataFetched = true;
92      }
93      // Close the client connection once done.
94      client.stop();
95    } else {
96      Serial.println("- Ethernet link disconnected!");
97    }
98  }
99}
100
101void printIPAddress()
102{
103  Serial.print("Connected to: ");
104  for (byte thisByte = 0; thisByte < 4; thisByte++) {
105    // print the value of each byte of the IP address:
106    Serial.print(Ethernet.localIP()[thisByte], DEC);
107    Serial.print(".");
108  }
109
110  Serial.println();
111}

Copy
1nmcli connection show  # To find the ethernet device name ("eth0" in this case)

Copy
1nmcli conn add con-name <NtwrkName> type ethernet ifname <DevName> ipv4.method auto # Create a DHCP network. <NtwrkName> will be the custom network alias and <DevName> must be the device name found with the past command.
2
3nmcli conn up <NtwrkName> # Initiate the connection

Copy
1ping -I eth0 -c 4 arduino.cc  # ping 4 times to Arduino's webpage using ethernet

Copy
1mkdir -p ~/bin && source ~/.profile
2wget -qO ~/bin/iperf3 https://github.com/userdocs/iperf3-static/releases/latest/download/iperf3-arm64v8
3chmod 700 ~/bin/iperf3

Copy
1~/bin/iperf3 -s # run this on the Portenta X8 (Server)

Copy
1iperf3.exe -c <Server IP Address> # run this on your PC (Windows) from the iperf3 download directory and use the Portenta X8 IP address.

Copy
1/**
2  Purpose: This sketch connects a device to ip-api.com via Ethernet
3  and fetches IP details for the device.
4**/
5
6// Include the necessary libraries.
7#if defined(ARDUINO_PORTENTA_H7_M7)
8  #include <PortentaEthernet.h> // for Portenta H7 
9#elif defined(ARDUINO_PORTENTA_C33)
10  #include <EthernetC33.h>  // for Portenta C33
11#endif
12
13#include <Arduino_JSON.h>
14
15// Server address for ip-api.com.
16const char* server = "ip-api.com";
17
18// API endpoint path to get IP details in JSON format.
19String path = "/json/";
20
21// Ethernet client instance for the communication.
22EthernetClient client;
23
24// JSON variable to store and process the fetched data.
25JSONVar doc;
26
27// Variable to ensure we fetch data only once.
28bool dataFetched = false;
29
30void setup() {
31  // Begin serial communication at a baud rate of 115200.
32  Serial.begin(115200);
33
34  // Wait for the serial port to connect,
35  // This is necessary for boards that have native USB.
36  while (!Serial);
37
38  // Attempt to start Ethernet connection via DHCP,
39  // If DHCP failed, print a diagnostic message.
40  if (Ethernet.begin() == 0) {
41    Serial.println("- Failed to configure Ethernet using DHCP!");
42
43  }
44  printIPAddress();
45  delay(2000);
46}
47
48void loop() {
49  // Ensure we haven't fetched data already,
50  // ensure the Ethernet link is active,
51  // establish a connection to the server,
52  // compose and send the HTTP GET request.
53  if (!dataFetched) {
54    if (Ethernet.linkStatus() == LinkON) {
55      if (client.connect(server, 80)) {
56        client.print("GET ");
57        client.print(path);
58        client.println(" HTTP/1.1");
59        client.print("Host: ");
60        client.println(server);
61        client.println("Connection: close");
62        client.println();
63
64        // Wait and skip the HTTP headers to get to the JSON data.
65        char endOfHeaders[] = "\r\n\r\n";
66        client.find(endOfHeaders);
67
68        // Read and parse the JSON response.
69        String payload = client.readString();
70        doc = JSON.parse(payload);
71
72        // Check if the parsing was successful.
73        if (JSON.typeof(doc) == "undefined") {
74          Serial.println("- Parsing failed!");
75          return;
76        }
77
78        // Extract and print the IP details.
79        Serial.println("*** IP Details:");
80        Serial.print("- IP Address: ");
81        Serial.println((const char*)doc["query"]);
82        Serial.print("- City: ");
83        Serial.println((const char*)doc["city"]);
84        Serial.print("- Region: ");
85        Serial.println((const char*)doc["regionName"]);
86        Serial.print("- Country: ");
87        Serial.println((const char*)doc["country"]);
88        Serial.println("");
89
90        // Mark data as fetched.
91        dataFetched = true;
92      }
93      // Close the client connection once done.
94      client.stop();
95    } else {
96      Serial.println("- Ethernet link disconnected!");
97    }
98  }
99}
100
101void printIPAddress()
102{
103  Serial.print("Connected to: ");
104  for (byte thisByte = 0; thisByte < 4; thisByte++) {
105    // print the value of each byte of the IP address:
106    Serial.print(Ethernet.localIP()[thisByte], DEC);
107    Serial.print(".");
108  }
109
110  Serial.println();
111}

Copy
1sudo mount -t vfat /dev/mmcblk1p1 /mnt

Copy
1docker run -it -u '0' --device '/dev/snd:/dev/snd' -v '/mnt:/sdcard' --tmpfs /tmp --name "alsa-utils" debian:stable-slim bash

Copy
1apt-get update && apt-get install alsa-utils ffmpeg -y

Copy
1amixer -c 1 sset 'ADC Left Mux' 'Input3A' # Mic Input
2amixer -c 1 sset 'ADC Right Mux' 'Input3B' # Mic Input
3amixer -c 1 sset 'ADC' 100% # Mic volume

Copy
1ffmpeg -f alsa -i hw:1 -t 30 -ac 1 -ar 44100 -c:a pcm_s16le /sdcard/out.wav

Copy
1# This sets the master output volume 
2amixer -c 1 sset 'Master' 100% # accepts also a dB parameter 100% = 12dB
3# This sets the headphone output volume 
4amixer -c 1 sset 'Headphone' 0dB # 0dB = 100%
5# This sets the speaker output volume 
6amixer -c 1 sset 'Speaker' 100% # 100% = 0dB

Copy
1amixer -c 1 sset 'SPK Right Amp' on # turn on the right channel speaker
2amixer -c 1 sset 'SPK Left Amp' on # turn on the right channel speaker

Copy
1speaker-test -c 2 -D hw:cs42l52audio -t wav

Copy
1speaker-test -c 2 -D hw:cs42l52audio -t sine -f 440

Copy
1aplay -c 2 -D hw:cs42l52audio -t wav /sdcard/out2.wav

Copy
1sudo su -

Copy
1lsblk

Copy
1mkdir -p /mnt/USBmount

Copy
1mount -t vfat /dev/sda1 /mnt/USBmount

Copy
1cd /mnt/USBmount

Copy
1ls

Copy
1dd if=<(echo -n "Hello, World!") of=/mnt/USBmount/helloworld.txt

Copy
1cat helloworld.txt

Copy
1umount /dev/sda1 /mnt/USBmount

Copy
1#include <Wire.h>
2#include "SparkFun_USB251x_Arduino_Library.h"   //Click here to install: http://librarymanager/All#USB251x
3#include <vector>
4#include <string>
5#include "UsbHostMsd.h"
6#include "FATFileSystem.h"
7
8#define TEST_FS_NAME "USB"
9#define TEST_FOLDER_NAME "TEST_FOLDER"
10#define TEST_FILE "test.txt"
11#define DELETE_FILE_DIMENSION 150
12
13USB251x myHub;
14USBHostMSD block_device;
15FATFileSystem fs(TEST_FS_NAME);
16
17std::string root_folder = std::string("/") + std::string(TEST_FS_NAME);
18std::string folder_test_name = root_folder + std::string("/") + std::string(TEST_FOLDER_NAME);
19std::string file_test_name = folder_test_name + std::string("/") + std::string(TEST_FILE);
20
21/* this callback will be called when a Mass Storage Device is plugged in */
22void device_attached_callback(void) {
23  Serial.println();
24  Serial.println("++++ Mass Storage Device detected ++++");
25  Serial.println();
26}
27
28void setup() {
29  /*
30   *  SERIAL INITIALIZATION
31   */
32  Serial.begin(115200);
33  while (!Serial) {
34  }
35
36  Wire.begin();
37
38  if (myHub.begin() == false) {
39    Serial.println("Device not found. USB251xB may already be in hub mode. Please check wiring or reset the hub. Freezing...");
40    while (1)
41      ;
42  }
43
44  Serial.println("Writing default settings to hub");
45  myHub.setDefaults();  //Write ROM defaults
46  myHub.attach();       //Locks settings and begin acting as hub
47
48
49  Serial.println();
50  Serial.println("*** USB HOST Mass Storage Device example ***");
51  Serial.println();
52
53  /* attach the callback so that when the device is inserted the device_attached_callback
54     will be automatically called */
55  block_device.attach_detected_callback(device_attached_callback);
56  /* list to store all directory in the root */
57  std::vector<std::string> dir_list;
58
59  /* 
60   *  Check for device to be connected
61   */
62
63  int count = 0;
64  while (!block_device.connect()) {
65    if (count == 0) {
66      Serial.println("Waiting for Mass Storage Device");
67    } else {
68      Serial.print(".");
69      if (count % 30 == 0) {
70        Serial.println();
71      }
72    }
73    count++;
74    delay(1000);
75  }
76
77  Serial.println("Mass Storage Device connected.");
78
79  /* 
80   *  MOUNTIN SDCARD AS FATFS filesystem
81   */
82
83  Serial.println("Mounting Mass Storage Device...");
84  int err = fs.mount(&block_device);
85  if (err) {
86    // Reformat if we can't mount the filesystem
87    // this should only happen on the first boot
88    Serial.println("No filesystem found, formatting... ");
89    err = fs.reformat(&block_device);
90  }
91
92  if (err) {
93    Serial.println("Error formatting USB Mass Storage Device");
94    while (1)
95      ;
96  }
97
98  /* 
99   *  READING root folder
100   */
101
102  DIR *dir;
103  struct dirent *ent;
104  int dirIndex = 0;
105
106  Serial.println("*** List USB Mass Storage Device content: ");
107  if ((dir = opendir(root_folder.c_str())) != NULL) {
108    while ((ent = readdir(dir)) != NULL) {
109      if (ent->d_type == DT_REG) {
110        Serial.print("- [File]: ");
111      } else if (ent->d_type == DT_DIR) {
112        Serial.print("- [Fold]: ");
113        if (ent->d_name[0] != '.') { /* avoid hidden folders (.Trash might contain a lot of files) */
114          dir_list.push_back(ent->d_name);
115        }
116      }
117      Serial.println(ent->d_name);
118      dirIndex++;
119    }
120    closedir(dir);
121  } else {
122    // Could not open directory
123    Serial.println("Error opening USB Mass Storage Device\n");
124    while (1)
125      ;
126  }
127
128  if (dirIndex == 0) {
129    Serial.println("Empty SDCARD");
130  }
131
132  bool found_test_folder = false;
133
134  /* 
135   *  LISTING CONTENT of the first level folders (the one immediately present in root folder)
136   */
137
138  if (dir_list.size()) {
139    Serial.println();
140    Serial.println("Listing content of folders in root: ");
141  }
142  for (unsigned int i = 0; i < dir_list.size(); i++) {
143    if (dir_list[i] == TEST_FOLDER_NAME) {
144      found_test_folder = true;
145    }
146    Serial.print("- ");
147    Serial.print(dir_list[i].c_str());
148    Serial.println(":");
149
150    std::string d = root_folder + std::string("/") + dir_list[i];
151    if ((dir = opendir(d.c_str())) != NULL) {
152      while ((ent = readdir(dir)) != NULL) {
153        if (ent->d_type == DT_REG) {
154          Serial.print("   - [File]: ");
155        } else if (ent->d_type == DT_DIR) {
156          Serial.print("   - [Fold]: ");
157        }
158        Serial.println(ent->d_name);
159      }
160      closedir(dir);
161    } else {
162      Serial.print("ERROR OPENING SUB-FOLDER ");
163      Serial.println(d.c_str());
164    }
165  }
166
167  /* 
168   *  CREATING TEST FOLDER (if does not exist already)
169   */
170
171  err = 0;
172  if (!found_test_folder) {
173    Serial.println("TEST FOLDER NOT FOUND... creating folder test");
174    err = mkdir(folder_test_name.c_str(), S_IRWXU | S_IRWXG | S_IRWXO);
175    if (err != 0) {
176      Serial.print("FAILED folder creation with error ");
177      Serial.println(err);
178    }
179  }
180
181  /* 
182   *  READING TEST FILE CONTENT
183   */
184
185  if (err == 0) {
186    int file_dimension = 0;
187    FILE *fp = fopen(file_test_name.c_str(), "r");
188    if (fp != NULL) {
189      Serial.print("Opened file: ");
190      Serial.print(file_test_name.c_str());
191      Serial.println(" for reading");
192
193      fseek(fp, 0L, SEEK_END);
194      int numbytes = ftell(fp);
195      fseek(fp, 0L, SEEK_SET);
196
197      Serial.print("Bytes in the file: ");
198      Serial.println(numbytes);
199      file_dimension = numbytes;
200
201      if (numbytes > 0) {
202        Serial.println();
203        Serial.println("-------------------- START FILE CONTENT --------------------");
204      }
205
206      for (int i = 0; i < numbytes; i++) {
207        char ch;
208        fread(&ch, sizeof(char), 1, fp);
209        Serial.print(ch);
210      }
211
212      if (numbytes > 0) {
213        Serial.println("--------------------- END FILE CONTENT ---------------------");
214        Serial.println();
215      } else {
216        Serial.println("File is EMPTY!");
217        Serial.println();
218      }
219
220      fclose(fp);
221    } else {
222      Serial.print("FAILED open file ");
223      Serial.println(file_test_name.c_str());
224    }
225
226    /*
227     * DELETE FILE IF THE File dimension is greater than 150 bytes
228     */
229
230    if (file_dimension > DELETE_FILE_DIMENSION) {
231      Serial.println("Test file reached the delete dimension... deleting it!");
232      if (remove(file_test_name.c_str()) == 0) {
233        Serial.println("TEST FILE HAS BEEN DELETED!");
234      }
235    }
236
237    /*
238     * APPENDING SOMETHING TO FILE 
239     */
240
241    fp = fopen(file_test_name.c_str(), "a");
242    if (fp != NULL) {
243      Serial.print("Opened file: ");
244      Serial.print(file_test_name.c_str());
245      Serial.println(" for writing (append)");
246      char text[] = "This line has been appended to file!\n";
247      fwrite(text, sizeof(char), strlen(text), fp);
248      fclose(fp);
249    } else {
250      Serial.print("FAILED open file for appending ");
251      Serial.println(file_test_name.c_str());
252    }
253
254    /*
255     * READING AGAIN FILE CONTENT
256     */
257
258    fp = fopen(file_test_name.c_str(), "r");
259    if (fp != NULL) {
260      Serial.print("Opened file: ");
261      Serial.print(file_test_name.c_str());
262      Serial.println(" for reading");
263
264      fseek(fp, 0L, SEEK_END);
265      int numbytes = ftell(fp);
266      fseek(fp, 0L, SEEK_SET);
267
268      Serial.print("Bytes in the file: ");
269      Serial.println(numbytes);
270
271      if (numbytes > 0) {
272        Serial.println();
273        Serial.println("-------------------- START FILE CONTENT --------------------");
274      }
275
276      for (int i = 0; i < numbytes; i++) {
277        char ch;
278        fread(&ch, sizeof(char), 1, fp);
279        Serial.print(ch);
280      }
281
282      if (numbytes > 0) {
283        Serial.println("--------------------- END FILE CONTENT ---------------------");
284        Serial.println();
285      } else {
286        Serial.println("File is EMPTY!");
287        Serial.println();
288      }
289
290      fclose(fp);
291
292    } else {
293      Serial.print("FAILED open file for appending ");
294      Serial.println(file_test_name.c_str());
295    }
296  }
297}
298
299void loop() {
300  // Empty
301}

Copy
1docker run -it --cap-add SYS_ADMIN --device /dev/mmcblk1p1 debian:stable-slim bash

Copy
1lsblk
2
3# or
4fdisk -l

Copy
1mkdir -p /tmp/sdcard

Copy
1mount /dev/mmcblk1p1 /tmp/sdcard

Copy
1cd /tmp/sdcard
2ls

Copy
1echo "Hello World Carrier!" > hello.txt

Copy
1cat hello.txt

Copy
1umount /tmp/sdcard

Copy
1mkfs.ext4 /dev/mmcblk1p1  #Warning: this will erase everything on your micro SD

Copy
1#include "SDMMCBlockDevice.h"
2#include "FATFileSystem.h"
3
4SDMMCBlockDevice block_device;
5mbed::FATFileSystem fs("fs");
6
7void setup() {
8  Serial.begin(9600);
9  while (!Serial);
10
11  Serial.println("Mounting SDCARD...");
12  int err =  fs.mount(&block_device);
13  if (err) {
14    // Reformat if we can't mount the filesystem
15    // this should only happen on the first boot
16    Serial.println("No filesystem found, formatting... ");
17    err = fs.reformat(&block_device);
18  }
19  if (err) {
20     Serial.println("Error formatting SDCARD ");
21     while(1);
22  }
23  
24  DIR *dir;
25  struct dirent *ent;
26  int dirIndex = 0;
27
28  Serial.println("List SDCARD content: ");
29  if ((dir = opendir("/fs")) != NULL) {
30    // Print all the files and directories within directory (not recursively)
31    while ((ent = readdir (dir)) != NULL) {
32      Serial.println(ent->d_name);
33      dirIndex++;
34    }
35    closedir (dir);
36  } else {
37    // Could not open directory
38    Serial.println("Error opening SDCARD\n");
39    while(1);
40  }
41  if(dirIndex == 0) {
42    Serial.println("Empty SDCARD");
43  }
44}
45
46void loop() {
47  // Empty
48}

Copy
1#include <vector>
2#include <string>
3#include "SDCardBlockDevice.h"
4#include "FATFileSystem.h"
5
6#define TEST_FS_NAME "fs"
7#define TEST_FOLDER_NAME "TEST_FOLDER"
8#define TEST_FILE "test.txt"
9#define DELETE_FILE_DIMENSION 150
10
11
12SDCardBlockDevice block_device(PIN_SDHI_CLK, PIN_SDHI_CMD, PIN_SDHI_D0, PIN_SDHI_D1, PIN_SDHI_D2, PIN_SDHI_D3, PIN_SDHI_CD, PIN_SDHI_WP);
13FATFileSystem fs(TEST_FS_NAME);
14
15std::string root_folder       = std::string("/") + std::string(TEST_FS_NAME);
16std::string folder_test_name  = root_folder + std::string("/") + std::string(TEST_FOLDER_NAME);
17std::string file_test_name    = folder_test_name + std::string("/") + std::string(TEST_FILE); 
18
19void setup() {
20  /*
21   *  SERIAL INITIALIZATION
22   */
23  Serial.begin(9600);
24  while(!Serial) {
25     
26  }
27
28  /* list to store all directory in the root */
29  std::vector<std::string> dir_list;
30
31  Serial.println();
32  Serial.println("##### TEST SD CARD with FAT FS");
33  Serial.println();
34
35  /* 
36   *  MOUNTING SDCARD AS FATFS filesystem
37   */
38  Serial.println("Mounting SDCARD...");
39  int err =  fs.mount(&block_device);
40  if (err) {
41    // Reformat if we can't mount the filesystem
42    // this should only happen on the first boot
43    Serial.println("No filesystem found, formatting... ");
44    err = fs.reformat(&block_device);
45  }
46  if (err) {
47     Serial.println("Error formatting SDCARD ");
48     while(1);
49  }
50
51  /* 
52   *  READING root folder
53   */
54  
55  DIR *dir;
56  struct dirent *ent;
57  int dirIndex = 0;
58
59  Serial.println("*** List SD CARD content: ");
60  if ((dir = opendir(root_folder.c_str())) != NULL) {
61    while ((ent = readdir (dir)) != NULL) {
62      
63      if(ent->d_type == DT_REG) {
64        Serial.print("- [File]: ");
65      }
66      
67      else if(ent->d_type == DT_DIR) {
68        Serial.print("- [Fold]: ");
69        dir_list.push_back(ent->d_name);
70      }
71      Serial.println(ent->d_name);
72      dirIndex++;
73    }
74    closedir (dir);
75  } 
76  else {
77    // Could not open directory
78    Serial.println("Error opening SDCARD\n");
79    while(1);
80  }
81
82  if(dirIndex == 0) {
83    Serial.println("Empty SDCARD");
84  }
85
86  bool found_test_folder = false;
87
88  /* 
89   *  LISTING CONTENT of the first level folders (the one immediately present in root folder)
90   */
91
92  if(dir_list.size()) {
93    Serial.println();
94    Serial.println("Listing content of folders in root: ");
95  }
96  for(unsigned int i = 0; i < dir_list.size(); i++) {
97    if(dir_list[i] == TEST_FOLDER_NAME) {
98      found_test_folder = true;
99    }
100    Serial.print("- ");
101    Serial.print(dir_list[i].c_str());
102    Serial.println(":");
103    
104    std::string d = root_folder + std::string("/") + dir_list[i];
105    if ((dir = opendir(d.c_str())) != NULL) {
106      while ((ent = readdir (dir)) != NULL) {
107        if(ent->d_type == DT_REG) {
108          Serial.print("   - [File]: ");
109        }
110        else if(ent->d_type == DT_DIR) {
111          Serial.print("   - [Fold]: ");
112        }
113        Serial.println(ent->d_name);
114      }
115      closedir (dir);
116    }
117    else {
118      Serial.print("ERROR OPENING SUB-FOLDER ");
119      Serial.println(d.c_str());
120    }
121  }
122
123  /* 
124   *  CREATING TEST FOLDER (if does not exist already)
125   */
126
127  err = 0;
128  if(!found_test_folder) {
129    Serial.println("TEST FOLDER NOT FOUND... creating folder test"); 
130    err = mkdir(folder_test_name.c_str(), S_IRWXU | S_IRWXG | S_IRWXO);
131    if(err != 0) {
132      Serial.print("FAILED folder creation with error ");
133      Serial.println(err);
134    }
135  }
136
137  /* 
138   *  READING TEST FILE CONTENT
139   */
140  
141  if(err == 0) {
142    int file_dimension = 0; 
143    FILE* fp = fopen(file_test_name.c_str(), "r");
144    if(fp != NULL) {
145      Serial.print("Opened file: ");
146      Serial.print(file_test_name.c_str());
147      Serial.println(" for reading");
148      
149      fseek(fp, 0L, SEEK_END);
150      int numbytes = ftell(fp);
151      fseek(fp, 0L, SEEK_SET);  
152
153      Serial.print("Bytes in the file: ");
154      Serial.println(numbytes);
155      file_dimension = numbytes;
156
157      if(numbytes > 0) {
158        Serial.println();
159        Serial.println("-------------------- START FILE CONTENT --------------------");
160      }
161      
162      for(int i = 0; i < numbytes; i++) {
163        char ch;
164        fread(&ch, sizeof(char), 1, fp);
165        Serial.print(ch);
166      }
167
168      if(numbytes > 0) {
169        Serial.println("--------------------- END FILE CONTENT ---------------------");
170        Serial.println();
171      }
172      else {
173        Serial.println("File is EMPTY!");
174        Serial.println();
175      }
176    
177      fclose(fp);
178    }
179    else {
180      Serial.print("FAILED open file ");
181      Serial.println(file_test_name.c_str());
182    }
183
184    /*
185     * DELETE FILE IF THE File dimension is greater than 150 bytes
186     */
187
188    if(file_dimension > DELETE_FILE_DIMENSION) {
189      Serial.println("Test file reached the delete dimension... deleting it!");
190      if(remove(file_test_name.c_str()) == 0) {
191        Serial.println("TEST FILE HAS BEEN DELETED!");
192      }
193    }
194    
195    /*
196     * APPENDING SOMETHING TO FILE 
197     */
198     
199    fp = fopen(file_test_name.c_str(), "a");
200    if(fp != NULL) {
201      Serial.print("Opened file: ");
202      Serial.print(file_test_name.c_str());
203      Serial.println(" for writing (append)");
204      char text[] = "This line has been appended to file!\n";
205      fwrite(text, sizeof(char), strlen(text), fp);
206      fclose(fp); 
207    }
208    else {
209      Serial.print("FAILED open file for appending ");
210      Serial.println(file_test_name.c_str());
211    }
212    
213    /*
214     * READING AGAIN FILE CONTENT
215     */
216    
217    fp = fopen(file_test_name.c_str(), "r");
218    if(fp != NULL) {
219      Serial.print("Opened file: ");
220      Serial.print(file_test_name.c_str());
221      Serial.println(" for reading");
222      
223      fseek(fp, 0L, SEEK_END);
224      int numbytes = ftell(fp);
225      fseek(fp, 0L, SEEK_SET);  
226
227      Serial.print("Bytes in the file: ");
228      Serial.println(numbytes);
229
230      if(numbytes > 0) {
231        Serial.println();
232        Serial.println("-------------------- START FILE CONTENT --------------------");
233      }
234      
235      for(int i = 0; i < numbytes; i++) {
236        char ch;
237        fread(&ch, sizeof(char), 1, fp);
238        Serial.print(ch);
239      }
240
241      if(numbytes > 0) {
242        Serial.println("--------------------- END FILE CONTENT ---------------------");
243        Serial.println();
244      }
245      else {
246        Serial.println("File is EMPTY!");
247        Serial.println();
248      }
249    
250      fclose(fp);
251      
252    }
253    else {
254      Serial.print("FAILED open file for appending ");
255      Serial.println(file_test_name.c_str());
256    }
257  }  
258  
259}
260
261void loop() {
262  // Empty
263}