Spell check all source files once again to find any typos.

Bootloaders/CDC/BootloaderCDC.txt

@@ -60,7 +60,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Bootloaders/DFU/BootloaderDFU.txt

@@ -71,7 +71,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Device/ClassDriver/AudioInput/AudioInput.txt

@@ -61,7 +61,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Device/ClassDriver/AudioOutput/AudioOutput.c

@@ -156,7 +156,7 @@ void EVENT_USB_Device_Connect(void)
 	/* PWM speaker timer initialization */
 	TCCR3A  = ((1 << WGM30) | (1 << COM3A1) | (1 << COM3A0)
 	        | (1 << COM3B1) | (1 << COM3B0)); // Set on match, clear on TOP
-	TCCR3B  = ((1 << WGM32) | (1 << CS30));  // Fast 8-Bit PWM, Fcpu speed
+	TCCR3B  = ((1 << WGM32) | (1 << CS30));  // Fast 8-Bit PWM, F_CPU speed
 #endif
 }
 

Demos/Device/ClassDriver/AudioOutput/AudioOutput.txt

@@ -63,7 +63,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Device/ClassDriver/DualVirtualSerial/DualVirtualSerial.txt

@@ -73,7 +73,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Device/ClassDriver/GenericHID/GenericHID.txt

@@ -57,7 +57,7 @@
  *
  *  \section SSec_Options Project Options
  *  
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Device/ClassDriver/Joystick/Joystick.txt

@@ -61,7 +61,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Device/ClassDriver/Keyboard/Keyboard.txt

@@ -60,7 +60,7 @@
  *
  *  \section SSec_Options Project Options
  *  
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Device/ClassDriver/KeyboardMouse/KeyboardMouse.txt

@@ -65,7 +65,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Device/ClassDriver/MIDI/MIDI.txt

@@ -62,7 +62,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Device/ClassDriver/MassStorage/Lib/DataflashManager.c

@@ -30,7 +30,7 @@
 
 /** \file
  *
- *  Functions to manage the physical dataflash media, including reading and writing of
+ *  Functions to manage the physical Dataflash media, including reading and writing of
  *  blocks of data. These functions are called by the SCSI layer when data must be stored
  *  or retrieved to/from the physical storage media. If a different media is used (such
  *  as a SD card or EEPROM), functions similar to these will need to be generated.
@@ -39,9 +39,9 @@
 #define  INCLUDE_FROM_DATAFLASHMANAGER_C
 #include "DataflashManager.h"
 
-/** Writes blocks (OS blocks, not Dataflash pages) to the storage medium, the board dataflash IC(s), from
+/** Writes blocks (OS blocks, not Dataflash pages) to the storage medium, the board Dataflash IC(s), from
  *  the pre-selected data OUT endpoint. This routine reads in OS sized blocks from the endpoint and writes
- *  them to the dataflash in Dataflash page sized blocks.
+ *  them to the Dataflash in Dataflash page sized blocks.
  *
  *  \param[in] MSInterfaceInfo  Pointer to a structure containing a Mass Storage Class configuration and state
  *  \param[in] BlockAddress  Data block starting address for the write sequence
@@ -60,13 +60,13 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 	Dataflash_SelectChipFromPage(CurrDFPage);
 
 #if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
-	/* Copy selected dataflash's current page contents to the dataflash buffer */
+	/* Copy selected dataflash's current page contents to the Dataflash buffer */
 	Dataflash_SendByte(DF_CMD_MAINMEMTOBUFF1);
 	Dataflash_SendAddressBytes(CurrDFPage, 0);
 	Dataflash_WaitWhileBusy();
 #endif
 
-	/* Send the dataflash buffer write command */
+	/* Send the Dataflash buffer write command */
 	Dataflash_SendByte(DF_CMD_BUFF1WRITE);
 	Dataflash_SendAddressBytes(0, CurrDFPageByte);
 
@@ -78,7 +78,7 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 	{
 		uint8_t BytesInBlockDiv16 = 0;
 		
-		/* Write an endpoint packet sized data block to the dataflash */
+		/* Write an endpoint packet sized data block to the Dataflash */
 		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
 		{
 			/* Check if the endpoint is currently empty */
@@ -92,30 +92,30 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 				  return;
 			}
 
-			/* Check if end of dataflash page reached */
+			/* Check if end of Dataflash page reached */
 			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
 			{
-				/* Write the dataflash buffer contents back to the dataflash page */
+				/* Write the Dataflash buffer contents back to the Dataflash page */
 				Dataflash_WaitWhileBusy();
 				Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);
 				Dataflash_SendAddressBytes(CurrDFPage, 0);
 
-				/* Reset the dataflash buffer counter, increment the page counter */
+				/* Reset the Dataflash buffer counter, increment the page counter */
 				CurrDFPageByteDiv16 = 0;
 				CurrDFPage++;
 
-				/* Once all the dataflash ICs have had their first buffers filled, switch buffers to maintain throughput */
+				/* Once all the Dataflash ICs have had their first buffers filled, switch buffers to maintain throughput */
 				if (Dataflash_GetSelectedChip() == DATAFLASH_CHIP_MASK(DATAFLASH_TOTALCHIPS))
 				  UsingSecondBuffer = !(UsingSecondBuffer);
 
-				/* Select the next dataflash chip based on the new dataflash page index */
+				/* Select the next Dataflash chip based on the new Dataflash page index */
 				Dataflash_SelectChipFromPage(CurrDFPage);
 
 #if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
-				/* If less than one dataflash page remaining, copy over the existing page to preserve trailing data */
+				/* If less than one Dataflash page remaining, copy over the existing page to preserve trailing data */
 				if ((TotalBlocks * (VIRTUAL_MEMORY_BLOCK_SIZE >> 4)) < (DATAFLASH_PAGE_SIZE >> 4))
 				{
-					/* Copy selected dataflash's current page contents to the dataflash buffer */
+					/* Copy selected dataflash's current page contents to the Dataflash buffer */
 					Dataflash_WaitWhileBusy();
 					Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_MAINMEMTOBUFF2 : DF_CMD_MAINMEMTOBUFF1);
 					Dataflash_SendAddressBytes(CurrDFPage, 0);
@@ -123,12 +123,12 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 				}
 #endif
 
-				/* Send the dataflash buffer write command */
+				/* Send the Dataflash buffer write command */
 				Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2WRITE : DF_CMD_BUFF1WRITE);
 				Dataflash_SendAddressBytes(0, 0);				
 			}
 
-			/* Write one 16-byte chunk of data to the dataflash */
+			/* Write one 16-byte chunk of data to the Dataflash */
 			Dataflash_SendByte(Endpoint_Read_Byte());
 			Dataflash_SendByte(Endpoint_Read_Byte());
 			Dataflash_SendByte(Endpoint_Read_Byte());
@@ -146,7 +146,7 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 			Dataflash_SendByte(Endpoint_Read_Byte());
 			Dataflash_SendByte(Endpoint_Read_Byte());
 			
-			/* Increment the dataflash page 16 byte block counter */
+			/* Increment the Dataflash page 16 byte block counter */
 			CurrDFPageByteDiv16++;
 
 			/* Increment the block 16 byte block counter */
@@ -161,7 +161,7 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 		TotalBlocks--;
 	}
 
-	/* Write the dataflash buffer contents back to the dataflash page */
+	/* Write the Dataflash buffer contents back to the Dataflash page */
 	Dataflash_WaitWhileBusy();
 	Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);
 	Dataflash_SendAddressBytes(CurrDFPage, 0x00);
@@ -171,11 +171,11 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 	if (!(Endpoint_IsReadWriteAllowed()))
 	  Endpoint_ClearOUT();
 
-	/* Deselect all dataflash chips */
+	/* Deselect all Dataflash chips */
 	Dataflash_DeselectChip();
 }
 
-/** Reads blocks (OS blocks, not Dataflash pages) from the storage medium, the board dataflash IC(s), into
+/** Reads blocks (OS blocks, not Dataflash pages) from the storage medium, the board Dataflash IC(s), into
  *  the pre-selected data IN endpoint. This routine reads in Dataflash page sized blocks from the Dataflash
  *  and writes them in OS sized blocks to the endpoint.
  *
@@ -194,7 +194,7 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 	/* Select the correct starting Dataflash IC for the block requested */
 	Dataflash_SelectChipFromPage(CurrDFPage);
 
-	/* Send the dataflash main memory page read command */
+	/* Send the Dataflash main memory page read command */
 	Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
 	Dataflash_SendAddressBytes(CurrDFPage, CurrDFPageByte);
 	Dataflash_SendByte(0x00);
@@ -210,7 +210,7 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 	{
 		uint8_t BytesInBlockDiv16 = 0;
 		
-		/* Write an endpoint packet sized data block to the dataflash */
+		/* Write an endpoint packet sized data block to the Dataflash */
 		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
 		{
 			/* Check if the endpoint is currently full */
@@ -224,17 +224,17 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 				  return;
 			}
 			
-			/* Check if end of dataflash page reached */
+			/* Check if end of Dataflash page reached */
 			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
 			{
-				/* Reset the dataflash buffer counter, increment the page counter */
+				/* Reset the Dataflash buffer counter, increment the page counter */
 				CurrDFPageByteDiv16 = 0;
 				CurrDFPage++;
 
-				/* Select the next dataflash chip based on the new dataflash page index */
+				/* Select the next Dataflash chip based on the new Dataflash page index */
 				Dataflash_SelectChipFromPage(CurrDFPage);
 				
-				/* Send the dataflash main memory page read command */
+				/* Send the Dataflash main memory page read command */
 				Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
 				Dataflash_SendAddressBytes(CurrDFPage, 0);
 				Dataflash_SendByte(0x00);
@@ -243,7 +243,7 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 				Dataflash_SendByte(0x00);
 			}	
 
-			/* Read one 16-byte chunk of data from the dataflash */
+			/* Read one 16-byte chunk of data from the Dataflash */
 			Endpoint_Write_Byte(Dataflash_ReceiveByte());
 			Endpoint_Write_Byte(Dataflash_ReceiveByte());
 			Endpoint_Write_Byte(Dataflash_ReceiveByte());
@@ -261,7 +261,7 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 			Endpoint_Write_Byte(Dataflash_ReceiveByte());
 			Endpoint_Write_Byte(Dataflash_ReceiveByte());
 			
-			/* Increment the dataflash page 16 byte block counter */
+			/* Increment the Dataflash page 16 byte block counter */
 			CurrDFPageByteDiv16++;
 			
 			/* Increment the block 16 byte block counter */
@@ -280,14 +280,14 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 	if (!(Endpoint_IsReadWriteAllowed()))
 	  Endpoint_ClearIN();
 
-	/* Deselect all dataflash chips */
+	/* Deselect all Dataflash chips */
 	Dataflash_DeselectChip();
 }
 
-/** Writes blocks (OS blocks, not Dataflash pages) to the storage medium, the board dataflash IC(s), from
+/** Writes blocks (OS blocks, not Dataflash pages) to the storage medium, the board Dataflash IC(s), from
  *  the a given RAM buffer. This routine reads in OS sized blocks from the buffer and writes them to the
- *  dataflash in Dataflash page sized blocks. This can be linked to FAT libraries to write files to the
+ *  Dataflash in Dataflash page sized blocks. This can be linked to FAT libraries to write files to the
- *  dataflash.
+ *  Dataflash.
  *
  *  \param[in] BlockAddress  Data block starting address for the write sequence
  *  \param[in] TotalBlocks   Number of blocks of data to write
@@ -306,13 +306,13 @@ void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress,
 	Dataflash_SelectChipFromPage(CurrDFPage);
 
 #if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
-	/* Copy selected dataflash's current page contents to the dataflash buffer */
+	/* Copy selected dataflash's current page contents to the Dataflash buffer */
 	Dataflash_SendByte(DF_CMD_MAINMEMTOBUFF1);
 	Dataflash_SendAddressBytes(CurrDFPage, 0);
 	Dataflash_WaitWhileBusy();
 #endif
 
-	/* Send the dataflash buffer write command */
+	/* Send the Dataflash buffer write command */
 	Dataflash_SendByte(DF_CMD_BUFF1WRITE);
 	Dataflash_SendAddressBytes(0, CurrDFPageByte);
 	
@@ -320,33 +320,33 @@ void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress,
 	{
 		uint8_t BytesInBlockDiv16 = 0;
 		
-		/* Write an endpoint packet sized data block to the dataflash */
+		/* Write an endpoint packet sized data block to the Dataflash */
 		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
 		{
-			/* Check if end of dataflash page reached */
+			/* Check if end of Dataflash page reached */
 			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
 			{
-				/* Write the dataflash buffer contents back to the dataflash page */
+				/* Write the Dataflash buffer contents back to the Dataflash page */
 				Dataflash_WaitWhileBusy();
 				Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);
 				Dataflash_SendAddressBytes(CurrDFPage, 0);
 
-				/* Reset the dataflash buffer counter, increment the page counter */
+				/* Reset the Dataflash buffer counter, increment the page counter */
 				CurrDFPageByteDiv16 = 0;
 				CurrDFPage++;
 
-				/* Once all the dataflash ICs have had their first buffers filled, switch buffers to maintain throughput */
+				/* Once all the Dataflash ICs have had their first buffers filled, switch buffers to maintain throughput */
 				if (Dataflash_GetSelectedChip() == DATAFLASH_CHIP_MASK(DATAFLASH_TOTALCHIPS))
 				  UsingSecondBuffer = !(UsingSecondBuffer);
 
-				/* Select the next dataflash chip based on the new dataflash page index */
+				/* Select the next Dataflash chip based on the new Dataflash page index */
 				Dataflash_SelectChipFromPage(CurrDFPage);
 
 #if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
-				/* If less than one dataflash page remaining, copy over the existing page to preserve trailing data */
+				/* If less than one Dataflash page remaining, copy over the existing page to preserve trailing data */
 				if ((TotalBlocks * (VIRTUAL_MEMORY_BLOCK_SIZE >> 4)) < (DATAFLASH_PAGE_SIZE >> 4))
 				{
-					/* Copy selected dataflash's current page contents to the dataflash buffer */
+					/* Copy selected dataflash's current page contents to the Dataflash buffer */
 					Dataflash_WaitWhileBusy();
 					Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_MAINMEMTOBUFF2 : DF_CMD_MAINMEMTOBUFF1);
 					Dataflash_SendAddressBytes(CurrDFPage, 0);
@@ -354,17 +354,17 @@ void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress,
 				}
 #endif
 
-				/* Send the dataflash buffer write command */
+				/* Send the Dataflash buffer write command */
 				Dataflash_ToggleSelectedChipCS();
 				Dataflash_SendByte(DF_CMD_BUFF1WRITE);
 				Dataflash_SendAddressBytes(0, 0);
 			}
 			
-			/* Write one 16-byte chunk of data to the dataflash */
+			/* Write one 16-byte chunk of data to the Dataflash */
 			for (uint8_t ByteNum = 0; ByteNum < 16; ByteNum++)
 			  Dataflash_SendByte(*(BufferPtr++));
 			
-			/* Increment the dataflash page 16 byte block counter */
+			/* Increment the Dataflash page 16 byte block counter */
 			CurrDFPageByteDiv16++;
 
 			/* Increment the block 16 byte block counter */
@@ -375,20 +375,20 @@ void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress,
 		TotalBlocks--;
 	}
 
-	/* Write the dataflash buffer contents back to the dataflash page */
+	/* Write the Dataflash buffer contents back to the Dataflash page */
 	Dataflash_WaitWhileBusy();
 	Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);
 	Dataflash_SendAddressBytes(CurrDFPage, 0x00);
 	Dataflash_WaitWhileBusy();
 
-	/* Deselect all dataflash chips */
+	/* Deselect all Dataflash chips */
 	Dataflash_DeselectChip();
 }
 
-/** Reads blocks (OS blocks, not Dataflash pages) from the storage medium, the board dataflash IC(s), into
+/** Reads blocks (OS blocks, not Dataflash pages) from the storage medium, the board Dataflash IC(s), into
  *  the a preallocated RAM buffer. This routine reads in Dataflash page sized blocks from the Dataflash
  *  and writes them in OS sized blocks to the given buffer. This can be linked to FAT libraries to read
- *  the files stored on the dataflash.
+ *  the files stored on the Dataflash.
  *
  *  \param[in] BlockAddress  Data block starting address for the read sequence
  *  \param[in] TotalBlocks   Number of blocks of data to read
@@ -405,7 +405,7 @@ void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress,
 	/* Select the correct starting Dataflash IC for the block requested */
 	Dataflash_SelectChipFromPage(CurrDFPage);
 
-	/* Send the dataflash main memory page read command */
+	/* Send the Dataflash main memory page read command */
 	Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
 	Dataflash_SendAddressBytes(CurrDFPage, CurrDFPageByte);
 	Dataflash_SendByte(0x00);
@@ -417,20 +417,20 @@ void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress,
 	{
 		uint8_t BytesInBlockDiv16 = 0;
 		
-		/* Write an endpoint packet sized data block to the dataflash */
+		/* Write an endpoint packet sized data block to the Dataflash */
 		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
 		{
-			/* Check if end of dataflash page reached */
+			/* Check if end of Dataflash page reached */
 			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
 			{
-				/* Reset the dataflash buffer counter, increment the page counter */
+				/* Reset the Dataflash buffer counter, increment the page counter */
 				CurrDFPageByteDiv16 = 0;
 				CurrDFPage++;
 
-				/* Select the next dataflash chip based on the new dataflash page index */
+				/* Select the next Dataflash chip based on the new Dataflash page index */
 				Dataflash_SelectChipFromPage(CurrDFPage);
 				
-				/* Send the dataflash main memory page read command */
+				/* Send the Dataflash main memory page read command */
 				Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
 				Dataflash_SendAddressBytes(CurrDFPage, 0);
 				Dataflash_SendByte(0x00);
@@ -439,11 +439,11 @@ void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress,
 				Dataflash_SendByte(0x00);
 			}	
 
-			/* Read one 16-byte chunk of data from the dataflash */
+			/* Read one 16-byte chunk of data from the Dataflash */
 			for (uint8_t ByteNum = 0; ByteNum < 16; ByteNum++)
 			  *(BufferPtr++) = Dataflash_ReceiveByte();
 			
-			/* Increment the dataflash page 16 byte block counter */
+			/* Increment the Dataflash page 16 byte block counter */
 			CurrDFPageByteDiv16++;
 			
 			/* Increment the block 16 byte block counter */
@@ -454,14 +454,14 @@ void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress,
 		TotalBlocks--;
 	}
 
-	/* Deselect all dataflash chips */
+	/* Deselect all Dataflash chips */
 	Dataflash_DeselectChip();
 }
 
-/** Disables the dataflash memory write protection bits on the board Dataflash ICs, if enabled. */
+/** Disables the Dataflash memory write protection bits on the board Dataflash ICs, if enabled. */
 void DataflashManager_ResetDataflashProtections(void)
 {
-	/* Select first dataflash chip, send the read status register command */
+	/* Select first Dataflash chip, send the read status register command */
 	Dataflash_SelectChip(DATAFLASH_CHIP1);
 	Dataflash_SendByte(DF_CMD_GETSTATUS);
 	
@@ -477,7 +477,7 @@ void DataflashManager_ResetDataflashProtections(void)
 		Dataflash_SendByte(DF_CMD_SECTORPROTECTIONOFF[3]);
 	}
 	
-	/* Select second dataflash chip (if present on selected board), send read status register command */
+	/* Select second Dataflash chip (if present on selected board), send read status register command */
 	#if (DATAFLASH_TOTALCHIPS == 2)
 	Dataflash_SelectChip(DATAFLASH_CHIP2);
 	Dataflash_SendByte(DF_CMD_GETSTATUS);
@@ -495,7 +495,7 @@ void DataflashManager_ResetDataflashProtections(void)
 	}
 	#endif
 	
-	/* Deselect current dataflash chip */
+	/* Deselect current Dataflash chip */
 	Dataflash_DeselectChip();
 }
 

Demos/Device/ClassDriver/MassStorage/Lib/DataflashManager.h

@@ -53,7 +53,7 @@
 		#endif
 
 	/* Defines: */
-		/** Total number of bytes of the storage medium, comprised of one or more dataflash ICs. */
+		/** Total number of bytes of the storage medium, comprised of one or more Dataflash ICs. */
 		#define VIRTUAL_MEMORY_BYTES                ((uint32_t)DATAFLASH_PAGES * DATAFLASH_PAGE_SIZE * DATAFLASH_TOTALCHIPS)
 
 		/** Block size of the device. This is kept at 512 to remain compatible with the OS despite the underlying

Demos/Device/ClassDriver/MassStorage/Lib/SCSI.c

@@ -241,7 +241,7 @@ static void SCSI_Command_Send_Diagnostic(USB_ClassInfo_MS_Device_t* const MSInte
 }
 
 /** Command processing for an issued SCSI READ (10) or WRITE (10) command. This command reads in the block start address
- *  and total number of blocks to process, then calls the appropriate low-level dataflash routine to handle the actual
+ *  and total number of blocks to process, then calls the appropriate low-level Dataflash routine to handle the actual
  *  reading and writing of the data.
  *
  *  \param[in] MSInterfaceInfo  Pointer to the Mass Storage class interface structure that the command is associated with

Demos/Device/ClassDriver/MassStorage/MassStorage.txt

@@ -74,7 +74,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Device/ClassDriver/MassStorageKeyboard/Lib/DataflashManager.c

@@ -30,7 +30,7 @@
 
 /** \file
  *
- *  Functions to manage the physical dataflash media, including reading and writing of
+ *  Functions to manage the physical Dataflash media, including reading and writing of
  *  blocks of data. These functions are called by the SCSI layer when data must be stored
  *  or retrieved to/from the physical storage media. If a different media is used (such
  *  as a SD card or EEPROM), functions similar to these will need to be generated.
@@ -39,9 +39,9 @@
 #define  INCLUDE_FROM_DATAFLASHMANAGER_C
 #include "DataflashManager.h"
 
-/** Writes blocks (OS blocks, not Dataflash pages) to the storage medium, the board dataflash IC(s), from
+/** Writes blocks (OS blocks, not Dataflash pages) to the storage medium, the board Dataflash IC(s), from
  *  the pre-selected data OUT endpoint. This routine reads in OS sized blocks from the endpoint and writes
- *  them to the dataflash in Dataflash page sized blocks.
+ *  them to the Dataflash in Dataflash page sized blocks.
  *
  *  \param[in] MSInterfaceInfo  Pointer to a structure containing a Mass Storage Class configuration and state
  *  \param[in] BlockAddress  Data block starting address for the write sequence
@@ -60,13 +60,13 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 	Dataflash_SelectChipFromPage(CurrDFPage);
 
 #if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
-	/* Copy selected dataflash's current page contents to the dataflash buffer */
+	/* Copy selected dataflash's current page contents to the Dataflash buffer */
 	Dataflash_SendByte(DF_CMD_MAINMEMTOBUFF1);
 	Dataflash_SendAddressBytes(CurrDFPage, 0);
 	Dataflash_WaitWhileBusy();
 #endif
 
-	/* Send the dataflash buffer write command */
+	/* Send the Dataflash buffer write command */
 	Dataflash_SendByte(DF_CMD_BUFF1WRITE);
 	Dataflash_SendAddressBytes(0, CurrDFPageByte);
 
@@ -78,7 +78,7 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 	{
 		uint8_t BytesInBlockDiv16 = 0;
 		
-		/* Write an endpoint packet sized data block to the dataflash */
+		/* Write an endpoint packet sized data block to the Dataflash */
 		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
 		{
 			/* Check if the endpoint is currently empty */
@@ -92,30 +92,30 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 				  return;
 			}
 
-			/* Check if end of dataflash page reached */
+			/* Check if end of Dataflash page reached */
 			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
 			{
-				/* Write the dataflash buffer contents back to the dataflash page */
+				/* Write the Dataflash buffer contents back to the Dataflash page */
 				Dataflash_WaitWhileBusy();
 				Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);
 				Dataflash_SendAddressBytes(CurrDFPage, 0);
 
-				/* Reset the dataflash buffer counter, increment the page counter */
+				/* Reset the Dataflash buffer counter, increment the page counter */
 				CurrDFPageByteDiv16 = 0;
 				CurrDFPage++;
 
-				/* Once all the dataflash ICs have had their first buffers filled, switch buffers to maintain throughput */
+				/* Once all the Dataflash ICs have had their first buffers filled, switch buffers to maintain throughput */
 				if (Dataflash_GetSelectedChip() == DATAFLASH_CHIP_MASK(DATAFLASH_TOTALCHIPS))
 				  UsingSecondBuffer = !(UsingSecondBuffer);
 
-				/* Select the next dataflash chip based on the new dataflash page index */
+				/* Select the next Dataflash chip based on the new Dataflash page index */
 				Dataflash_SelectChipFromPage(CurrDFPage);
 
 #if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
-				/* If less than one dataflash page remaining, copy over the existing page to preserve trailing data */
+				/* If less than one Dataflash page remaining, copy over the existing page to preserve trailing data */
 				if ((TotalBlocks * (VIRTUAL_MEMORY_BLOCK_SIZE >> 4)) < (DATAFLASH_PAGE_SIZE >> 4))
 				{
-					/* Copy selected dataflash's current page contents to the dataflash buffer */
+					/* Copy selected dataflash's current page contents to the Dataflash buffer */
 					Dataflash_WaitWhileBusy();
 					Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_MAINMEMTOBUFF2 : DF_CMD_MAINMEMTOBUFF1);
 					Dataflash_SendAddressBytes(CurrDFPage, 0);
@@ -123,12 +123,12 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 				}
 #endif
 
-				/* Send the dataflash buffer write command */
+				/* Send the Dataflash buffer write command */
 				Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2WRITE : DF_CMD_BUFF1WRITE);
 				Dataflash_SendAddressBytes(0, 0);				
 			}
 
-			/* Write one 16-byte chunk of data to the dataflash */
+			/* Write one 16-byte chunk of data to the Dataflash */
 			Dataflash_SendByte(Endpoint_Read_Byte());
 			Dataflash_SendByte(Endpoint_Read_Byte());
 			Dataflash_SendByte(Endpoint_Read_Byte());
@@ -146,7 +146,7 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 			Dataflash_SendByte(Endpoint_Read_Byte());
 			Dataflash_SendByte(Endpoint_Read_Byte());
 			
-			/* Increment the dataflash page 16 byte block counter */
+			/* Increment the Dataflash page 16 byte block counter */
 			CurrDFPageByteDiv16++;
 
 			/* Increment the block 16 byte block counter */
@@ -161,7 +161,7 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 		TotalBlocks--;
 	}
 
-	/* Write the dataflash buffer contents back to the dataflash page */
+	/* Write the Dataflash buffer contents back to the Dataflash page */
 	Dataflash_WaitWhileBusy();
 	Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);
 	Dataflash_SendAddressBytes(CurrDFPage, 0x00);
@@ -171,11 +171,11 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 	if (!(Endpoint_IsReadWriteAllowed()))
 	  Endpoint_ClearOUT();
 
-	/* Deselect all dataflash chips */
+	/* Deselect all Dataflash chips */
 	Dataflash_DeselectChip();
 }
 
-/** Reads blocks (OS blocks, not Dataflash pages) from the storage medium, the board dataflash IC(s), into
+/** Reads blocks (OS blocks, not Dataflash pages) from the storage medium, the board Dataflash IC(s), into
  *  the pre-selected data IN endpoint. This routine reads in Dataflash page sized blocks from the Dataflash
  *  and writes them in OS sized blocks to the endpoint.
  *
@@ -194,7 +194,7 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 	/* Select the correct starting Dataflash IC for the block requested */
 	Dataflash_SelectChipFromPage(CurrDFPage);
 
-	/* Send the dataflash main memory page read command */
+	/* Send the Dataflash main memory page read command */
 	Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
 	Dataflash_SendAddressBytes(CurrDFPage, CurrDFPageByte);
 	Dataflash_SendByte(0x00);
@@ -210,7 +210,7 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 	{
 		uint8_t BytesInBlockDiv16 = 0;
 		
-		/* Write an endpoint packet sized data block to the dataflash */
+		/* Write an endpoint packet sized data block to the Dataflash */
 		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
 		{
 			/* Check if the endpoint is currently full */
@@ -224,17 +224,17 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 				  return;
 			}
 			
-			/* Check if end of dataflash page reached */
+			/* Check if end of Dataflash page reached */
 			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
 			{
-				/* Reset the dataflash buffer counter, increment the page counter */
+				/* Reset the Dataflash buffer counter, increment the page counter */
 				CurrDFPageByteDiv16 = 0;
 				CurrDFPage++;
 
-				/* Select the next dataflash chip based on the new dataflash page index */
+				/* Select the next Dataflash chip based on the new Dataflash page index */
 				Dataflash_SelectChipFromPage(CurrDFPage);
 				
-				/* Send the dataflash main memory page read command */
+				/* Send the Dataflash main memory page read command */
 				Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
 				Dataflash_SendAddressBytes(CurrDFPage, 0);
 				Dataflash_SendByte(0x00);
@@ -243,7 +243,7 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 				Dataflash_SendByte(0x00);
 			}	
 
-			/* Read one 16-byte chunk of data from the dataflash */
+			/* Read one 16-byte chunk of data from the Dataflash */
 			Endpoint_Write_Byte(Dataflash_ReceiveByte());
 			Endpoint_Write_Byte(Dataflash_ReceiveByte());
 			Endpoint_Write_Byte(Dataflash_ReceiveByte());
@@ -261,7 +261,7 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 			Endpoint_Write_Byte(Dataflash_ReceiveByte());
 			Endpoint_Write_Byte(Dataflash_ReceiveByte());
 			
-			/* Increment the dataflash page 16 byte block counter */
+			/* Increment the Dataflash page 16 byte block counter */
 			CurrDFPageByteDiv16++;
 			
 			/* Increment the block 16 byte block counter */
@@ -280,14 +280,14 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 	if (!(Endpoint_IsReadWriteAllowed()))
 	  Endpoint_ClearIN();
 
-	/* Deselect all dataflash chips */
+	/* Deselect all Dataflash chips */
 	Dataflash_DeselectChip();
 }
 
-/** Writes blocks (OS blocks, not Dataflash pages) to the storage medium, the board dataflash IC(s), from
+/** Writes blocks (OS blocks, not Dataflash pages) to the storage medium, the board Dataflash IC(s), from
  *  the a given RAM buffer. This routine reads in OS sized blocks from the buffer and writes them to the
- *  dataflash in Dataflash page sized blocks. This can be linked to FAT libraries to write files to the
+ *  Dataflash in Dataflash page sized blocks. This can be linked to FAT libraries to write files to the
- *  dataflash.
+ *  Dataflash.
  *
  *  \param[in] BlockAddress  Data block starting address for the write sequence
  *  \param[in] TotalBlocks   Number of blocks of data to write
@@ -306,13 +306,13 @@ void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress,
 	Dataflash_SelectChipFromPage(CurrDFPage);
 
 #if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
-	/* Copy selected dataflash's current page contents to the dataflash buffer */
+	/* Copy selected dataflash's current page contents to the Dataflash buffer */
 	Dataflash_SendByte(DF_CMD_MAINMEMTOBUFF1);
 	Dataflash_SendAddressBytes(CurrDFPage, 0);
 	Dataflash_WaitWhileBusy();
 #endif
 
-	/* Send the dataflash buffer write command */
+	/* Send the Dataflash buffer write command */
 	Dataflash_SendByte(DF_CMD_BUFF1WRITE);
 	Dataflash_SendAddressBytes(0, CurrDFPageByte);
 	
@@ -320,33 +320,33 @@ void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress,
 	{
 		uint8_t BytesInBlockDiv16 = 0;
 		
-		/* Write an endpoint packet sized data block to the dataflash */
+		/* Write an endpoint packet sized data block to the Dataflash */
 		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
 		{
-			/* Check if end of dataflash page reached */
+			/* Check if end of Dataflash page reached */
 			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
 			{
-				/* Write the dataflash buffer contents back to the dataflash page */
+				/* Write the Dataflash buffer contents back to the Dataflash page */
 				Dataflash_WaitWhileBusy();
 				Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);
 				Dataflash_SendAddressBytes(CurrDFPage, 0);
 
-				/* Reset the dataflash buffer counter, increment the page counter */
+				/* Reset the Dataflash buffer counter, increment the page counter */
 				CurrDFPageByteDiv16 = 0;
 				CurrDFPage++;
 
-				/* Once all the dataflash ICs have had their first buffers filled, switch buffers to maintain throughput */
+				/* Once all the Dataflash ICs have had their first buffers filled, switch buffers to maintain throughput */
 				if (Dataflash_GetSelectedChip() == DATAFLASH_CHIP_MASK(DATAFLASH_TOTALCHIPS))
 				  UsingSecondBuffer = !(UsingSecondBuffer);
 
-				/* Select the next dataflash chip based on the new dataflash page index */
+				/* Select the next Dataflash chip based on the new Dataflash page index */
 				Dataflash_SelectChipFromPage(CurrDFPage);
 
 #if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
-				/* If less than one dataflash page remaining, copy over the existing page to preserve trailing data */
+				/* If less than one Dataflash page remaining, copy over the existing page to preserve trailing data */
 				if ((TotalBlocks * (VIRTUAL_MEMORY_BLOCK_SIZE >> 4)) < (DATAFLASH_PAGE_SIZE >> 4))
 				{
-					/* Copy selected dataflash's current page contents to the dataflash buffer */
+					/* Copy selected dataflash's current page contents to the Dataflash buffer */
 					Dataflash_WaitWhileBusy();
 					Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_MAINMEMTOBUFF2 : DF_CMD_MAINMEMTOBUFF1);
 					Dataflash_SendAddressBytes(CurrDFPage, 0);
@@ -354,17 +354,17 @@ void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress,
 				}
 #endif
 
-				/* Send the dataflash buffer write command */
+				/* Send the Dataflash buffer write command */
 				Dataflash_ToggleSelectedChipCS();
 				Dataflash_SendByte(DF_CMD_BUFF1WRITE);
 				Dataflash_SendAddressBytes(0, 0);
 			}
 			
-			/* Write one 16-byte chunk of data to the dataflash */
+			/* Write one 16-byte chunk of data to the Dataflash */
 			for (uint8_t ByteNum = 0; ByteNum < 16; ByteNum++)
 			  Dataflash_SendByte(*(BufferPtr++));
 			
-			/* Increment the dataflash page 16 byte block counter */
+			/* Increment the Dataflash page 16 byte block counter */
 			CurrDFPageByteDiv16++;
 
 			/* Increment the block 16 byte block counter */
@@ -375,20 +375,20 @@ void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress,
 		TotalBlocks--;
 	}
 
-	/* Write the dataflash buffer contents back to the dataflash page */
+	/* Write the Dataflash buffer contents back to the Dataflash page */
 	Dataflash_WaitWhileBusy();
 	Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);
 	Dataflash_SendAddressBytes(CurrDFPage, 0x00);
 	Dataflash_WaitWhileBusy();
 
-	/* Deselect all dataflash chips */
+	/* Deselect all Dataflash chips */
 	Dataflash_DeselectChip();
 }
 
-/** Reads blocks (OS blocks, not Dataflash pages) from the storage medium, the board dataflash IC(s), into
+/** Reads blocks (OS blocks, not Dataflash pages) from the storage medium, the board Dataflash IC(s), into
  *  the a preallocated RAM buffer. This routine reads in Dataflash page sized blocks from the Dataflash
  *  and writes them in OS sized blocks to the given buffer. This can be linked to FAT libraries to read
- *  the files stored on the dataflash.
+ *  the files stored on the Dataflash.
  *
  *  \param[in] BlockAddress  Data block starting address for the read sequence
  *  \param[in] TotalBlocks   Number of blocks of data to read
@@ -405,7 +405,7 @@ void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress,
 	/* Select the correct starting Dataflash IC for the block requested */
 	Dataflash_SelectChipFromPage(CurrDFPage);
 
-	/* Send the dataflash main memory page read command */
+	/* Send the Dataflash main memory page read command */
 	Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
 	Dataflash_SendAddressBytes(CurrDFPage, CurrDFPageByte);
 	Dataflash_SendByte(0x00);
@@ -417,20 +417,20 @@ void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress,
 	{
 		uint8_t BytesInBlockDiv16 = 0;
 		
-		/* Write an endpoint packet sized data block to the dataflash */
+		/* Write an endpoint packet sized data block to the Dataflash */
 		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
 		{
-			/* Check if end of dataflash page reached */
+			/* Check if end of Dataflash page reached */
 			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
 			{
-				/* Reset the dataflash buffer counter, increment the page counter */
+				/* Reset the Dataflash buffer counter, increment the page counter */
 				CurrDFPageByteDiv16 = 0;
 				CurrDFPage++;
 
-				/* Select the next dataflash chip based on the new dataflash page index */
+				/* Select the next Dataflash chip based on the new Dataflash page index */
 				Dataflash_SelectChipFromPage(CurrDFPage);
 				
-				/* Send the dataflash main memory page read command */
+				/* Send the Dataflash main memory page read command */
 				Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
 				Dataflash_SendAddressBytes(CurrDFPage, 0);
 				Dataflash_SendByte(0x00);
@@ -439,11 +439,11 @@ void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress,
 				Dataflash_SendByte(0x00);
 			}	
 
-			/* Read one 16-byte chunk of data from the dataflash */
+			/* Read one 16-byte chunk of data from the Dataflash */
 			for (uint8_t ByteNum = 0; ByteNum < 16; ByteNum++)
 			  *(BufferPtr++) = Dataflash_ReceiveByte();
 			
-			/* Increment the dataflash page 16 byte block counter */
+			/* Increment the Dataflash page 16 byte block counter */
 			CurrDFPageByteDiv16++;
 			
 			/* Increment the block 16 byte block counter */
@@ -454,14 +454,14 @@ void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress,
 		TotalBlocks--;
 	}
 
-	/* Deselect all dataflash chips */
+	/* Deselect all Dataflash chips */
 	Dataflash_DeselectChip();
 }
 
-/** Disables the dataflash memory write protection bits on the board Dataflash ICs, if enabled. */
+/** Disables the Dataflash memory write protection bits on the board Dataflash ICs, if enabled. */
 void DataflashManager_ResetDataflashProtections(void)
 {
-	/* Select first dataflash chip, send the read status register command */
+	/* Select first Dataflash chip, send the read status register command */
 	Dataflash_SelectChip(DATAFLASH_CHIP1);
 	Dataflash_SendByte(DF_CMD_GETSTATUS);
 	
@@ -477,7 +477,7 @@ void DataflashManager_ResetDataflashProtections(void)
 		Dataflash_SendByte(DF_CMD_SECTORPROTECTIONOFF[3]);
 	}
 	
-	/* Select second dataflash chip (if present on selected board), send read status register command */
+	/* Select second Dataflash chip (if present on selected board), send read status register command */
 	#if (DATAFLASH_TOTALCHIPS == 2)
 	Dataflash_SelectChip(DATAFLASH_CHIP2);
 	Dataflash_SendByte(DF_CMD_GETSTATUS);
@@ -495,6 +495,6 @@ void DataflashManager_ResetDataflashProtections(void)
 	}
 	#endif
 	
-	/* Deselect current dataflash chip */
+	/* Deselect current Dataflash chip */
 	Dataflash_DeselectChip();
 }

Demos/Device/ClassDriver/MassStorageKeyboard/Lib/DataflashManager.h

@@ -52,7 +52,7 @@
 		#endif
 
 	/* Defines: */
-		/** Total number of bytes of the storage medium, comprised of one or more dataflash ICs. */
+		/** Total number of bytes of the storage medium, comprised of one or more Dataflash ICs. */
 		#define VIRTUAL_MEMORY_BYTES                ((uint32_t)DATAFLASH_PAGES * DATAFLASH_PAGE_SIZE * DATAFLASH_TOTALCHIPS)
 
 		/** Block size of the device. This is kept at 512 to remain compatible with the OS despite the underlying

Demos/Device/ClassDriver/MassStorageKeyboard/Lib/SCSI.c

@@ -292,7 +292,7 @@ static bool SCSI_Command_Send_Diagnostic(USB_ClassInfo_MS_Device_t* const MSInte
 }
 
 /** Command processing for an issued SCSI READ (10) or WRITE (10) command. This command reads in the block start address
- *  and total number of blocks to process, then calls the appropriate low-level dataflash routine to handle the actual
+ *  and total number of blocks to process, then calls the appropriate low-level Dataflash routine to handle the actual
  *  reading and writing of the data.
  *
  *  \param[in] MSInterfaceInfo  Pointer to the Mass Storage class interface structure that the command is associated with

Demos/Device/ClassDriver/MassStorageKeyboard/MassStorageKeyboard.txt

@@ -74,7 +74,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Device/ClassDriver/Mouse/Mouse.txt

@@ -60,7 +60,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Device/ClassDriver/RNDISEthernet/Lib/Ethernet.c

@@ -31,7 +31,7 @@
 /** \file
  *
  *  Ethernet frame packet handling routines. This protocol handles the processing of raw Ethernet
- *  frames sent and received, deferring the processing of subpacket protocols to the appropriate
+ *  frames sent and received, deferring the processing of sub-packet protocols to the appropriate
  *  protocol handlers, such as DHCP or ARP.
  */
  

Demos/Device/ClassDriver/RNDISEthernet/RNDISEthernet.txt

@@ -75,7 +75,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Device/ClassDriver/VirtualSerial/VirtualSerial.txt

@@ -60,7 +60,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Device/ClassDriver/VirtualSerialMouse/VirtualSerialMouse.txt

@@ -64,7 +64,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Device/Incomplete/Sideshow/Descriptors.c

@@ -194,7 +194,7 @@ uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,
 					Size    = pgm_read_byte(&SerialNumberString.Header.Size);
 					break;
 				case 0xEE:
-					/* A Microsoft-proprietary extention. String address 0xEE is used by Windows for
+					/* A Microsoft-proprietary extension. String address 0xEE is used by Windows for
 					   "OS Descriptors", which in this case allows us to indicate that our device is
 					   Sideshow compatible regardless of VID/PID values. */
 					Address = (void*)&OSDescriptorString;

Demos/Device/Incomplete/TestAndMeasurement/TestAndMeasurement.c

@@ -53,7 +53,7 @@ TMC_Capabilities_t Capabilities =
 	};
 
 /** Current TMC control request that is being processed */
-uint8_t RequestInProgess   = 0;
+uint8_t RequestInProgress   = 0;
 
 /** Stream callback abort flag for bulk IN data */
 bool IsTMCBulkINReset      = false;
@@ -153,7 +153,7 @@ void EVENT_USB_Device_UnhandledControlRequest(void)
 				Endpoint_ClearSETUP();
 				
 				/* Check that no split transaction is already in progress and the data transfer tag is valid */
-				if (RequestInProgess != 0)
+				if (RequestInProgress != 0)
 				{
 					TMCRequestStatus = TMC_STATUS_SPLIT_IN_PROGRESS;
 				}
@@ -167,7 +167,7 @@ void EVENT_USB_Device_UnhandledControlRequest(void)
 					IsTMCBulkOUTReset = true;
 					
 					/* Save the split request for later checking when a new request is received */
-					RequestInProgess = Req_InitiateAbortBulkOut;
+					RequestInProgress = Req_InitiateAbortBulkOut;
 				}
 				
 				/* Write the request response byte */
@@ -184,12 +184,12 @@ void EVENT_USB_Device_UnhandledControlRequest(void)
 				Endpoint_ClearSETUP();
 				
 				/* Check that an ABORT BULK OUT transaction has been requested and that the request has completed */
-				if (RequestInProgess != Req_InitiateAbortBulkOut)
+				if (RequestInProgress != Req_InitiateAbortBulkOut)
 				  TMCRequestStatus = TMC_STATUS_SPLIT_NOT_IN_PROGRESS;				
 				else if (IsTMCBulkOUTReset)
 				  TMCRequestStatus = TMC_STATUS_PENDING;
 				else
-				  RequestInProgess = 0;			
+				  RequestInProgress = 0;			
 				
 				/* Write the request response bytes */
 				Endpoint_Write_Byte(TMCRequestStatus);
@@ -207,7 +207,7 @@ void EVENT_USB_Device_UnhandledControlRequest(void)
 				Endpoint_ClearSETUP();
 				
 				/* Check that no split transaction is already in progress and the data transfer tag is valid */
-				if (RequestInProgess != 0)
+				if (RequestInProgress != 0)
 				{
 					TMCRequestStatus = TMC_STATUS_SPLIT_IN_PROGRESS;				
 				}
@@ -221,7 +221,7 @@ void EVENT_USB_Device_UnhandledControlRequest(void)
 					IsTMCBulkINReset = true;
 					
 					/* Save the split request for later checking when a new request is received */
-					RequestInProgess = Req_InitiateAbortBulkIn;
+					RequestInProgress = Req_InitiateAbortBulkIn;
 				}
 				
 				/* Write the request response bytes */
@@ -239,12 +239,12 @@ void EVENT_USB_Device_UnhandledControlRequest(void)
 				Endpoint_ClearSETUP();
 				
 				/* Check that an ABORT BULK IN transaction has been requested and that the request has completed */
-				if (RequestInProgess != Req_InitiateAbortBulkIn)
+				if (RequestInProgress != Req_InitiateAbortBulkIn)
 				  TMCRequestStatus = TMC_STATUS_SPLIT_NOT_IN_PROGRESS;
 				else if (IsTMCBulkINReset)
 				  TMCRequestStatus = TMC_STATUS_PENDING;
 				else
-				  RequestInProgess = 0;
+				  RequestInProgress = 0;
 				
 				/* Write the request response bytes */
 				Endpoint_Write_Byte(TMCRequestStatus);
@@ -262,7 +262,7 @@ void EVENT_USB_Device_UnhandledControlRequest(void)
 				Endpoint_ClearSETUP();
 				
 				/* Check that no split transaction is already in progress */
-				if (RequestInProgess != 0)
+				if (RequestInProgress != 0)
 				{
 					Endpoint_Write_Byte(TMC_STATUS_SPLIT_IN_PROGRESS);				
 				}
@@ -273,7 +273,7 @@ void EVENT_USB_Device_UnhandledControlRequest(void)
 					IsTMCBulkOUTReset = true;
 					
 					/* Save the split request for later checking when a new request is received */
-					RequestInProgess = Req_InitiateClear;
+					RequestInProgress = Req_InitiateClear;
 				}
 				
 				/* Write the request response byte */
@@ -290,12 +290,12 @@ void EVENT_USB_Device_UnhandledControlRequest(void)
 				Endpoint_ClearSETUP();
 				
 				/* Check that a CLEAR transaction has been requested and that the request has completed */
-				if (RequestInProgess != Req_InitiateClear)
+				if (RequestInProgress != Req_InitiateClear)
 				  TMCRequestStatus = TMC_STATUS_SPLIT_NOT_IN_PROGRESS;				
 				else if (IsTMCBulkINReset || IsTMCBulkOUTReset)
 				  TMCRequestStatus = TMC_STATUS_PENDING;
 				else
-				  RequestInProgess = 0;
+				  RequestInProgress = 0;
 				
 				/* Write the request response bytes */
 				Endpoint_Write_Byte(TMCRequestStatus);

Demos/Device/LowLevel/AudioInput/AudioInput.txt

@@ -61,7 +61,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Device/LowLevel/AudioOutput/AudioOutput.c

@@ -99,7 +99,7 @@ void EVENT_USB_Device_Connect(void)
 	/* PWM speaker timer initialization */
 	TCCR3A  = ((1 << WGM30) | (1 << COM3A1) | (1 << COM3A0)
 	                        | (1 << COM3B1) | (1 << COM3B0)); // Set on match, clear on TOP
-	TCCR3B  = ((1 << WGM32) | (1 << CS30));  // Fast 8-Bit PWM, Fcpu speed
+	TCCR3B  = ((1 << WGM32) | (1 << CS30));  // Fast 8-Bit PWM, F_CPU speed
 #endif	
 }
 

Demos/Device/LowLevel/AudioOutput/AudioOutput.txt

@@ -63,7 +63,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Device/LowLevel/DualVirtualSerial/DualVirtualSerial.txt

@@ -73,7 +73,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Device/LowLevel/GenericHID/GenericHID.txt

@@ -57,7 +57,7 @@
  *
  *  \section SSec_Options Project Options
  *  
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Device/LowLevel/Joystick/Joystick.txt

@@ -61,7 +61,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Device/LowLevel/Keyboard/Keyboard.txt

@@ -60,7 +60,7 @@
  *
  *  \section SSec_Options Project Options
  *  
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Device/LowLevel/KeyboardMouse/KeyboardMouse.c

@@ -197,7 +197,7 @@ void EVENT_USB_Device_UnhandledControlRequest(void)
 /** Processes a given Keyboard LED report from the host, and sets the board LEDs to match. Since the Keyboard
  *  LED report can be sent through either the control endpoint (via a HID SetReport request) or the HID OUT
  *  endpoint, the processing code is placed here to avoid duplicating it and potentially having different
- *  behaviour depending on the method used to sent it.
+ *  behavior depending on the method used to sent it.
  */
 void Keyboard_ProcessLEDReport(const uint8_t LEDStatus)
 {

Demos/Device/LowLevel/KeyboardMouse/KeyboardMouse.txt

@@ -65,7 +65,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Device/LowLevel/MIDI/MIDI.txt

@@ -62,7 +62,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Device/LowLevel/MassStorage/Lib/DataflashManager.c

@@ -30,7 +30,7 @@
 
 /** \file
  *
- *  Functions to manage the physical dataflash media, including reading and writing of
+ *  Functions to manage the physical Dataflash media, including reading and writing of
  *  blocks of data. These functions are called by the SCSI layer when data must be stored
  *  or retrieved to/from the physical storage media. If a different media is used (such
  *  as a SD card or EEPROM), functions similar to these will need to be generated.
@@ -39,9 +39,9 @@
 #define  INCLUDE_FROM_DATAFLASHMANAGER_C
 #include "DataflashManager.h"
 
-/** Writes blocks (OS blocks, not Dataflash pages) to the storage medium, the board dataflash IC(s), from
+/** Writes blocks (OS blocks, not Dataflash pages) to the storage medium, the board Dataflash IC(s), from
  *  the pre-selected data OUT endpoint. This routine reads in OS sized blocks from the endpoint and writes
- *  them to the dataflash in Dataflash page sized blocks.
+ *  them to the Dataflash in Dataflash page sized blocks.
  *
  *  \param[in] BlockAddress  Data block starting address for the write sequence
  *  \param[in] TotalBlocks   Number of blocks of data to write
@@ -58,13 +58,13 @@ void DataflashManager_WriteBlocks(const uint32_t BlockAddress,
 	Dataflash_SelectChipFromPage(CurrDFPage);
 
 #if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
-	/* Copy selected dataflash's current page contents to the dataflash buffer */
+	/* Copy selected dataflash's current page contents to the Dataflash buffer */
 	Dataflash_SendByte(DF_CMD_MAINMEMTOBUFF1);
 	Dataflash_SendAddressBytes(CurrDFPage, 0);
 	Dataflash_WaitWhileBusy();
 #endif
 
-	/* Send the dataflash buffer write command */
+	/* Send the Dataflash buffer write command */
 	Dataflash_SendByte(DF_CMD_BUFF1WRITE);
 	Dataflash_SendAddressBytes(0, CurrDFPageByte);
 
@@ -76,7 +76,7 @@ void DataflashManager_WriteBlocks(const uint32_t BlockAddress,
 	{
 		uint8_t BytesInBlockDiv16 = 0;
 		
-		/* Write an endpoint packet sized data block to the dataflash */
+		/* Write an endpoint packet sized data block to the Dataflash */
 		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
 		{
 			/* Check if the endpoint is currently empty */
@@ -90,30 +90,30 @@ void DataflashManager_WriteBlocks(const uint32_t BlockAddress,
 				  return;
 			}
 
-			/* Check if end of dataflash page reached */
+			/* Check if end of Dataflash page reached */
 			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
 			{
-				/* Write the dataflash buffer contents back to the dataflash page */
+				/* Write the Dataflash buffer contents back to the Dataflash page */
 				Dataflash_WaitWhileBusy();
 				Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);
 				Dataflash_SendAddressBytes(CurrDFPage, 0);
 
-				/* Reset the dataflash buffer counter, increment the page counter */
+				/* Reset the Dataflash buffer counter, increment the page counter */
 				CurrDFPageByteDiv16 = 0;
 				CurrDFPage++;
 
-				/* Once all the dataflash ICs have had their first buffers filled, switch buffers to maintain throughput */
+				/* Once all the Dataflash ICs have had their first buffers filled, switch buffers to maintain throughput */
 				if (Dataflash_GetSelectedChip() == DATAFLASH_CHIP_MASK(DATAFLASH_TOTALCHIPS))
 				  UsingSecondBuffer = !(UsingSecondBuffer);
 
-				/* Select the next dataflash chip based on the new dataflash page index */
+				/* Select the next Dataflash chip based on the new Dataflash page index */
 				Dataflash_SelectChipFromPage(CurrDFPage);
 
 #if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
-				/* If less than one dataflash page remaining, copy over the existing page to preserve trailing data */
+				/* If less than one Dataflash page remaining, copy over the existing page to preserve trailing data */
 				if ((TotalBlocks * (VIRTUAL_MEMORY_BLOCK_SIZE >> 4)) < (DATAFLASH_PAGE_SIZE >> 4))
 				{
-					/* Copy selected dataflash's current page contents to the dataflash buffer */
+					/* Copy selected dataflash's current page contents to the Dataflash buffer */
 					Dataflash_WaitWhileBusy();
 					Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_MAINMEMTOBUFF2 : DF_CMD_MAINMEMTOBUFF1);
 					Dataflash_SendAddressBytes(CurrDFPage, 0);
@@ -121,12 +121,12 @@ void DataflashManager_WriteBlocks(const uint32_t BlockAddress,
 				}
 #endif
 
-				/* Send the dataflash buffer write command */
+				/* Send the Dataflash buffer write command */
 				Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2WRITE : DF_CMD_BUFF1WRITE);
 				Dataflash_SendAddressBytes(0, 0);				
 			}
 
-			/* Write one 16-byte chunk of data to the dataflash */
+			/* Write one 16-byte chunk of data to the Dataflash */
 			Dataflash_SendByte(Endpoint_Read_Byte());
 			Dataflash_SendByte(Endpoint_Read_Byte());
 			Dataflash_SendByte(Endpoint_Read_Byte());
@@ -144,7 +144,7 @@ void DataflashManager_WriteBlocks(const uint32_t BlockAddress,
 			Dataflash_SendByte(Endpoint_Read_Byte());
 			Dataflash_SendByte(Endpoint_Read_Byte());
 			
-			/* Increment the dataflash page 16 byte block counter */
+			/* Increment the Dataflash page 16 byte block counter */
 			CurrDFPageByteDiv16++;
 
 			/* Increment the block 16 byte block counter */
@@ -159,7 +159,7 @@ void DataflashManager_WriteBlocks(const uint32_t BlockAddress,
 		TotalBlocks--;
 	}
 
-	/* Write the dataflash buffer contents back to the dataflash page */
+	/* Write the Dataflash buffer contents back to the Dataflash page */
 	Dataflash_WaitWhileBusy();
 	Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);
 	Dataflash_SendAddressBytes(CurrDFPage, 0x00);
@@ -169,11 +169,11 @@ void DataflashManager_WriteBlocks(const uint32_t BlockAddress,
 	if (!(Endpoint_IsReadWriteAllowed()))
 	  Endpoint_ClearOUT();
 
-	/* Deselect all dataflash chips */
+	/* Deselect all Dataflash chips */
 	Dataflash_DeselectChip();
 }
 
-/** Reads blocks (OS blocks, not Dataflash pages) from the storage medium, the board dataflash IC(s), into
+/** Reads blocks (OS blocks, not Dataflash pages) from the storage medium, the board Dataflash IC(s), into
  *  the pre-selected data IN endpoint. This routine reads in Dataflash page sized blocks from the Dataflash
  *  and writes them in OS sized blocks to the endpoint.
  *
@@ -190,7 +190,7 @@ void DataflashManager_ReadBlocks(const uint32_t BlockAddress,
 	/* Select the correct starting Dataflash IC for the block requested */
 	Dataflash_SelectChipFromPage(CurrDFPage);
 
-	/* Send the dataflash main memory page read command */
+	/* Send the Dataflash main memory page read command */
 	Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
 	Dataflash_SendAddressBytes(CurrDFPage, CurrDFPageByte);
 	Dataflash_SendByte(0x00);
@@ -206,7 +206,7 @@ void DataflashManager_ReadBlocks(const uint32_t BlockAddress,
 	{
 		uint8_t BytesInBlockDiv16 = 0;
 		
-		/* Write an endpoint packet sized data block to the dataflash */
+		/* Write an endpoint packet sized data block to the Dataflash */
 		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
 		{
 			/* Check if the endpoint is currently full */
@@ -220,17 +220,17 @@ void DataflashManager_ReadBlocks(const uint32_t BlockAddress,
 				  return;
 			}
 			
-			/* Check if end of dataflash page reached */
+			/* Check if end of Dataflash page reached */
 			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
 			{
-				/* Reset the dataflash buffer counter, increment the page counter */
+				/* Reset the Dataflash buffer counter, increment the page counter */
 				CurrDFPageByteDiv16 = 0;
 				CurrDFPage++;
 
-				/* Select the next dataflash chip based on the new dataflash page index */
+				/* Select the next Dataflash chip based on the new Dataflash page index */
 				Dataflash_SelectChipFromPage(CurrDFPage);
 				
-				/* Send the dataflash main memory page read command */
+				/* Send the Dataflash main memory page read command */
 				Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
 				Dataflash_SendAddressBytes(CurrDFPage, 0);
 				Dataflash_SendByte(0x00);
@@ -239,7 +239,7 @@ void DataflashManager_ReadBlocks(const uint32_t BlockAddress,
 				Dataflash_SendByte(0x00);
 			}	
 
-			/* Read one 16-byte chunk of data from the dataflash */
+			/* Read one 16-byte chunk of data from the Dataflash */
 			Endpoint_Write_Byte(Dataflash_ReceiveByte());
 			Endpoint_Write_Byte(Dataflash_ReceiveByte());
 			Endpoint_Write_Byte(Dataflash_ReceiveByte());
@@ -257,7 +257,7 @@ void DataflashManager_ReadBlocks(const uint32_t BlockAddress,
 			Endpoint_Write_Byte(Dataflash_ReceiveByte());
 			Endpoint_Write_Byte(Dataflash_ReceiveByte());
 			
-			/* Increment the dataflash page 16 byte block counter */
+			/* Increment the Dataflash page 16 byte block counter */
 			CurrDFPageByteDiv16++;
 			
 			/* Increment the block 16 byte block counter */
@@ -276,14 +276,14 @@ void DataflashManager_ReadBlocks(const uint32_t BlockAddress,
 	if (!(Endpoint_IsReadWriteAllowed()))
 	  Endpoint_ClearIN();
 
-	/* Deselect all dataflash chips */
+	/* Deselect all Dataflash chips */
 	Dataflash_DeselectChip();
 }
 
-/** Writes blocks (OS blocks, not Dataflash pages) to the storage medium, the board dataflash IC(s), from
+/** Writes blocks (OS blocks, not Dataflash pages) to the storage medium, the board Dataflash IC(s), from
  *  the a given RAM buffer. This routine reads in OS sized blocks from the buffer and writes them to the
- *  dataflash in Dataflash page sized blocks. This can be linked to FAT libraries to write files to the
+ *  Dataflash in Dataflash page sized blocks. This can be linked to FAT libraries to write files to the
- *  dataflash.
+ *  Dataflash.
  *
  *  \param[in] BlockAddress  Data block starting address for the write sequence
  *  \param[in] TotalBlocks   Number of blocks of data to write
@@ -302,13 +302,13 @@ void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress,
 	Dataflash_SelectChipFromPage(CurrDFPage);
 
 #if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
-	/* Copy selected dataflash's current page contents to the dataflash buffer */
+	/* Copy selected dataflash's current page contents to the Dataflash buffer */
 	Dataflash_SendByte(DF_CMD_MAINMEMTOBUFF1);
 	Dataflash_SendAddressBytes(CurrDFPage, 0);
 	Dataflash_WaitWhileBusy();
 #endif
 
-	/* Send the dataflash buffer write command */
+	/* Send the Dataflash buffer write command */
 	Dataflash_SendByte(DF_CMD_BUFF1WRITE);
 	Dataflash_SendAddressBytes(0, CurrDFPageByte);
 
@@ -316,33 +316,33 @@ void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress,
 	{
 		uint8_t BytesInBlockDiv16 = 0;
 		
-		/* Write an endpoint packet sized data block to the dataflash */
+		/* Write an endpoint packet sized data block to the Dataflash */
 		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
 		{
-			/* Check if end of dataflash page reached */
+			/* Check if end of Dataflash page reached */
 			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
 			{
-				/* Write the dataflash buffer contents back to the dataflash page */
+				/* Write the Dataflash buffer contents back to the Dataflash page */
 				Dataflash_WaitWhileBusy();
 				Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);
 				Dataflash_SendAddressBytes(CurrDFPage, 0);
 
-				/* Reset the dataflash buffer counter, increment the page counter */
+				/* Reset the Dataflash buffer counter, increment the page counter */
 				CurrDFPageByteDiv16 = 0;
 				CurrDFPage++;
 
-				/* Once all the dataflash ICs have had their first buffers filled, switch buffers to maintain throughput */
+				/* Once all the Dataflash ICs have had their first buffers filled, switch buffers to maintain throughput */
 				if (Dataflash_GetSelectedChip() == DATAFLASH_CHIP_MASK(DATAFLASH_TOTALCHIPS))
 				  UsingSecondBuffer = !(UsingSecondBuffer);
 
-				/* Select the next dataflash chip based on the new dataflash page index */
+				/* Select the next Dataflash chip based on the new Dataflash page index */
 				Dataflash_SelectChipFromPage(CurrDFPage);
 
 #if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
-				/* If less than one dataflash page remaining, copy over the existing page to preserve trailing data */
+				/* If less than one Dataflash page remaining, copy over the existing page to preserve trailing data */
 				if ((TotalBlocks * (VIRTUAL_MEMORY_BLOCK_SIZE >> 4)) < (DATAFLASH_PAGE_SIZE >> 4))
 				{
-					/* Copy selected dataflash's current page contents to the dataflash buffer */
+					/* Copy selected dataflash's current page contents to the Dataflash buffer */
 					Dataflash_WaitWhileBusy();
 					Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_MAINMEMTOBUFF2 : DF_CMD_MAINMEMTOBUFF1);
 					Dataflash_SendAddressBytes(CurrDFPage, 0);
@@ -350,17 +350,17 @@ void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress,
 				}
 #endif
 
-				/* Send the dataflash buffer write command */
+				/* Send the Dataflash buffer write command */
 				Dataflash_ToggleSelectedChipCS();
 				Dataflash_SendByte(DF_CMD_BUFF1WRITE);
 				Dataflash_SendAddressBytes(0, 0);
 			}
 			
-			/* Write one 16-byte chunk of data to the dataflash */
+			/* Write one 16-byte chunk of data to the Dataflash */
 			for (uint8_t ByteNum = 0; ByteNum < 16; ByteNum++)
 			  Dataflash_SendByte(*(BufferPtr++));
 			
-			/* Increment the dataflash page 16 byte block counter */
+			/* Increment the Dataflash page 16 byte block counter */
 			CurrDFPageByteDiv16++;
 
 			/* Increment the block 16 byte block counter */
@@ -371,20 +371,20 @@ void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress,
 		TotalBlocks--;
 	}
 
-	/* Write the dataflash buffer contents back to the dataflash page */
+	/* Write the Dataflash buffer contents back to the Dataflash page */
 	Dataflash_WaitWhileBusy();
 	Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);
 	Dataflash_SendAddressBytes(CurrDFPage, 0x00);
 	Dataflash_WaitWhileBusy();
 
-	/* Deselect all dataflash chips */
+	/* Deselect all Dataflash chips */
 	Dataflash_DeselectChip();
 }
 
-/** Reads blocks (OS blocks, not Dataflash pages) from the storage medium, the board dataflash IC(s), into
+/** Reads blocks (OS blocks, not Dataflash pages) from the storage medium, the board Dataflash IC(s), into
  *  the a preallocated RAM buffer. This routine reads in Dataflash page sized blocks from the Dataflash
  *  and writes them in OS sized blocks to the given buffer. This can be linked to FAT libraries to read
- *  the files stored on the dataflash.
+ *  the files stored on the Dataflash.
  *
  *  \param[in] BlockAddress  Data block starting address for the read sequence
  *  \param[in] TotalBlocks   Number of blocks of data to read
@@ -401,7 +401,7 @@ void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress,
 	/* Select the correct starting Dataflash IC for the block requested */
 	Dataflash_SelectChipFromPage(CurrDFPage);
 
-	/* Send the dataflash main memory page read command */
+	/* Send the Dataflash main memory page read command */
 	Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
 	Dataflash_SendAddressBytes(CurrDFPage, CurrDFPageByte);
 	Dataflash_SendByte(0x00);
@@ -413,20 +413,20 @@ void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress,
 	{
 		uint8_t BytesInBlockDiv16 = 0;
 		
-		/* Write an endpoint packet sized data block to the dataflash */
+		/* Write an endpoint packet sized data block to the Dataflash */
 		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
 		{
-			/* Check if end of dataflash page reached */
+			/* Check if end of Dataflash page reached */
 			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
 			{
-				/* Reset the dataflash buffer counter, increment the page counter */
+				/* Reset the Dataflash buffer counter, increment the page counter */
 				CurrDFPageByteDiv16 = 0;
 				CurrDFPage++;
 
-				/* Select the next dataflash chip based on the new dataflash page index */
+				/* Select the next Dataflash chip based on the new Dataflash page index */
 				Dataflash_SelectChipFromPage(CurrDFPage);
 				
-				/* Send the dataflash main memory page read command */
+				/* Send the Dataflash main memory page read command */
 				Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
 				Dataflash_SendAddressBytes(CurrDFPage, 0);
 				Dataflash_SendByte(0x00);
@@ -435,11 +435,11 @@ void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress,
 				Dataflash_SendByte(0x00);
 			}	
 
-			/* Read one 16-byte chunk of data from the dataflash */
+			/* Read one 16-byte chunk of data from the Dataflash */
 			for (uint8_t ByteNum = 0; ByteNum < 16; ByteNum++)
 			  *(BufferPtr++) = Dataflash_ReceiveByte();
 			
-			/* Increment the dataflash page 16 byte block counter */
+			/* Increment the Dataflash page 16 byte block counter */
 			CurrDFPageByteDiv16++;
 			
 			/* Increment the block 16 byte block counter */
@@ -450,14 +450,14 @@ void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress,
 		TotalBlocks--;
 	}
 
-	/* Deselect all dataflash chips */
+	/* Deselect all Dataflash chips */
 	Dataflash_DeselectChip();
 }
 
-/** Disables the dataflash memory write protection bits on the board Dataflash ICs, if enabled. */
+/** Disables the Dataflash memory write protection bits on the board Dataflash ICs, if enabled. */
 void DataflashManager_ResetDataflashProtections(void)
 {
-	/* Select first dataflash chip, send the read status register command */
+	/* Select first Dataflash chip, send the read status register command */
 	Dataflash_SelectChip(DATAFLASH_CHIP1);
 	Dataflash_SendByte(DF_CMD_GETSTATUS);
 	
@@ -473,7 +473,7 @@ void DataflashManager_ResetDataflashProtections(void)
 		Dataflash_SendByte(DF_CMD_SECTORPROTECTIONOFF[3]);
 	}
 	
-	/* Select second dataflash chip (if present on selected board), send read status register command */
+	/* Select second Dataflash chip (if present on selected board), send read status register command */
 	#if (DATAFLASH_TOTALCHIPS == 2)
 	Dataflash_SelectChip(DATAFLASH_CHIP2);
 	Dataflash_SendByte(DF_CMD_GETSTATUS);
@@ -491,7 +491,7 @@ void DataflashManager_ResetDataflashProtections(void)
 	}
 	#endif
 	
-	/* Deselect current dataflash chip */
+	/* Deselect current Dataflash chip */
 	Dataflash_DeselectChip();
 }
 

Demos/Device/LowLevel/MassStorage/Lib/DataflashManager.h

@@ -52,7 +52,7 @@
 		#endif
 
 	/* Defines: */
-		/** Total number of bytes of the storage medium, comprised of one or more dataflash ICs. */
+		/** Total number of bytes of the storage medium, comprised of one or more Dataflash ICs. */
 		#define VIRTUAL_MEMORY_BYTES                ((uint32_t)DATAFLASH_PAGES * DATAFLASH_PAGE_SIZE * DATAFLASH_TOTALCHIPS)
 
 		/** Block size of the device. This is kept at 512 to remain compatible with the OS despite the underlying

Demos/Device/LowLevel/MassStorage/Lib/SCSI.c

@@ -245,7 +245,7 @@ static void SCSI_Command_Send_Diagnostic(void)
 }
 
 /** Command processing for an issued SCSI READ (10) or WRITE (10) command. This command reads in the block start address
- *  and total number of blocks to process, then calls the appropriate low-level dataflash routine to handle the actual
+ *  and total number of blocks to process, then calls the appropriate low-level Dataflash routine to handle the actual
  *  reading and writing of the data.
  *
  *  \param[in] IsDataRead  Indicates if the command is a READ (10) command or WRITE (10) command (DATA_READ or DATA_WRITE)

Demos/Device/LowLevel/MassStorage/MassStorage.txt

@@ -74,7 +74,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Device/LowLevel/Mouse/Mouse.txt

@@ -60,7 +60,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Device/LowLevel/RNDISEthernet/Lib/RNDIS.h

@@ -131,7 +131,7 @@
 			uint32_t AFListSize;
 		} RNDIS_Initialize_Complete_t;
 		
-		/** Type define for a RNDIS Keepalive command message. */
+		/** Type define for a RNDIS Keep-alive command message. */
 		typedef struct
 		{
 			uint32_t MessageType;
@@ -139,7 +139,7 @@
 			uint32_t RequestId;
 		} RNDIS_KeepAlive_Message_t;
 
-		/** Type define for a RNDIS Keepalive complete message. */
+		/** Type define for a RNDIS Keep-alive complete message. */
 		typedef struct
 		{
 			uint32_t MessageType;

Demos/Device/LowLevel/RNDISEthernet/RNDISEthernet.txt

@@ -75,7 +75,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Device/LowLevel/VirtualSerial/VirtualSerial.txt

@@ -60,7 +60,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/DualRole/ClassDriver/MouseHostDevice/MouseHostDevice.txt

@@ -67,7 +67,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Host/ClassDriver/JoystickHostWithParser/JoystickHostWithParser.txt

@@ -58,7 +58,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Host/ClassDriver/KeyboardHost/KeyboardHost.txt

@@ -58,7 +58,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Host/ClassDriver/KeyboardHostWithParser/KeyboardHostWithParser.c

@@ -143,7 +143,7 @@ int main(void)
 							/* Key code is an unsigned char in length, cast to the appropriate type */
 							uint8_t KeyCode = (uint8_t)ReportItem->Value;
 
-							/* If scancode is non-zero, a key is being pressed */
+							/* If scan-code is non-zero, a key is being pressed */
 							if (KeyCode)
 							{
 								/* Toggle status LED to indicate keypress */
@@ -151,7 +151,7 @@ int main(void)
 
 								char PressedKey = 0;
 
-								/* Convert scancode to printable character if alphanumeric */
+								/* Convert scan-code to printable character if alphanumeric */
 								if ((KeyCode >= 0x04) && (KeyCode <= 0x1D))
 								  PressedKey = (KeyCode - 0x04) + 'A';
 								else if ((KeyCode >= 0x1E) && (KeyCode <= 0x27))
@@ -166,7 +166,7 @@ int main(void)
 								  putchar(PressedKey);
 							}
 							
-							/* Once a scancode is found, stop scanning through the report items */
+							/* Once a scan-code is found, stop scanning through the report items */
 							break;
 						}
 					}

Demos/Host/ClassDriver/KeyboardHostWithParser/KeyboardHostWithParser.txt

@@ -58,7 +58,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Host/ClassDriver/MIDIHost/MIDIHost.txt

@@ -47,7 +47,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Host/ClassDriver/MassStorageHost/MassStorageHost.txt

@@ -55,7 +55,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Host/ClassDriver/MouseHost/MouseHost.txt

@@ -61,7 +61,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Host/ClassDriver/MouseHostWithParser/MouseHostWithParser.txt

@@ -58,7 +58,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Host/ClassDriver/PrinterHost/PrinterHost.txt

@@ -53,7 +53,7 @@
  *  
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Host/ClassDriver/RNDISEthernetHost/RNDISEthernetHost.txt

@@ -50,7 +50,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Host/ClassDriver/StillImageHost/StillImageHost.txt

@@ -52,7 +52,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Host/ClassDriver/VirtualSerialHost/VirtualSerialHost.txt

@@ -53,7 +53,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Host/Incomplete/BluetoothHost/Lib/RFCOMM.c

@@ -263,7 +263,7 @@ uint16_t RFCOMM_GetVariableFieldValue(const uint8_t** BufferPos)
 		  (*BufferPos)++;
 	}
 
-	/* Bitshift the bytes that comprise the variable length field so that they form a single integer */
+	/* Bit-shift the bytes that comprise the variable length field so that they form a single integer */
 	return (((uint16_t)SecondOctet << 7) | FirstOctet >> 1);
 }
 

Demos/Host/Incomplete/BluetoothHost/Lib/SDP.c

@@ -480,7 +480,7 @@ static bool SDP_SearchServiceTable(uint8_t UUIDList[][UUID_SIZE_BYTES],
 	return (UUIDMatches == TotalUUIDs);
 }
 
-/** Recursively upwraps the given locally stored attribute (in PROGMEM space), searching for UUIDs to match against
+/** Recursively unwraps the given locally stored attribute (in PROGMEM space), searching for UUIDs to match against
  *  the given UUID list. As matches are found, they are indicated in the UUIDMatch flag list.
  *
  *  \param[in]      UUIDList        List of UUIDs which must be matched within the service attribute table

Demos/Host/LowLevel/GenericHIDHost/GenericHIDHost.txt

@@ -51,7 +51,7 @@
  *  
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Host/LowLevel/JoystickHostWithParser/JoystickHostWithParser.txt

@@ -58,7 +58,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Host/LowLevel/KeyboardHost/KeyboardHost.txt

@@ -60,7 +60,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Host/LowLevel/KeyboardHostWithParser/KeyboardHostWithParser.c

@@ -254,13 +254,13 @@ void ProcessKeyboardReport(uint8_t* KeyboardReport)
 		/* Create a temporary item pointer to the next report item */
 		HID_ReportItem_t* ReportItem = &HIDReportInfo.ReportItems[ReportNumber];
 
-		/* Check if the current report item is a keyboard scancode */
+		/* Check if the current report item is a keyboard scan-code */
 		if ((ReportItem->Attributes.Usage.Page      == USAGE_PAGE_KEYBOARD) &&
 			(ReportItem->Attributes.BitSize         == 8)                   &&
 			(ReportItem->Attributes.Logical.Maximum > 1)                    &&
 			(ReportItem->ItemType                   == REPORT_ITEM_TYPE_In))
 		{
-			/* Retrieve the keyboard scancode from the report data retrieved from the device */
+			/* Retrieve the keyboard scan-code from the report data retrieved from the device */
 			bool FoundData = USB_GetHIDReportItemInfo(KeyboardReport, ReportItem);
 			
 			/* For multi-report devices - if the requested data was not in the issued report, continue */
@@ -270,7 +270,7 @@ void ProcessKeyboardReport(uint8_t* KeyboardReport)
 			/* Key code is an unsigned char in length, cast to the appropriate type */
 			uint8_t KeyCode = (uint8_t)ReportItem->Value;
 
-			/* If scancode is non-zero, a key is being pressed */
+			/* If scan-code is non-zero, a key is being pressed */
 			if (KeyCode)
 			{
 				/* Toggle status LED to indicate keypress */
@@ -278,7 +278,7 @@ void ProcessKeyboardReport(uint8_t* KeyboardReport)
 
 				char PressedKey = 0;
 
-				/* Convert scancode to printable character if alphanumeric */
+				/* Convert scan-code to printable character if alphanumeric */
 				if ((KeyCode >= 0x04) && (KeyCode <= 0x1D))
 				  PressedKey = (KeyCode - 0x04) + 'A';
 				else if ((KeyCode >= 0x1E) && (KeyCode <= 0x27))
@@ -293,7 +293,7 @@ void ProcessKeyboardReport(uint8_t* KeyboardReport)
 				  putchar(PressedKey);
 			}
 			
-			/* Once a scancode is found, stop scanning through the report items */
+			/* Once a scan-code is found, stop scanning through the report items */
 			break;
 		}
 	}

Demos/Host/LowLevel/KeyboardHostWithParser/KeyboardHostWithParser.txt

@@ -58,7 +58,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Host/LowLevel/MIDIHost/MIDIHost.txt

@@ -47,7 +47,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Host/LowLevel/MassStorageHost/MassStorageHost.txt

@@ -55,7 +55,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Host/LowLevel/MouseHost/MouseHost.txt

@@ -61,7 +61,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Host/LowLevel/MouseHostWithParser/MouseHostWithParser.txt

@@ -58,7 +58,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Host/LowLevel/PrinterHost/PrinterHost.txt

@@ -50,7 +50,7 @@
  *  
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Host/LowLevel/RNDISEthernetHost/Lib/RNDISCommands.c

@@ -184,7 +184,7 @@ uint8_t RNDIS_SetRNDISProperty(const uint32_t Oid,
 	struct
 	{
 		RNDIS_Set_Message_t SetMessage;
-		uint8_t             ContigiousBuffer[Length];
+		uint8_t             ContiguousBuffer[Length];
 	} SetMessageData;
 	
 	RNDIS_Set_Complete_t SetMessageResponse;
@@ -198,7 +198,7 @@ uint8_t RNDIS_SetRNDISProperty(const uint32_t Oid,
 	SetMessageData.SetMessage.InformationBufferOffset = (sizeof(RNDIS_Set_Message_t) - sizeof(RNDIS_Message_Header_t));
 	SetMessageData.SetMessage.DeviceVcHandle = 0;
 	
-	memcpy(&SetMessageData.ContigiousBuffer, Buffer, Length);
+	memcpy(&SetMessageData.ContiguousBuffer, Buffer, Length);
 
 	if ((ErrorCode = RNDIS_SendEncapsulatedCommand(&SetMessageData,
 	                                               SetMessageData.SetMessage.MessageLength)) != HOST_SENDCONTROL_Successful)
@@ -238,7 +238,7 @@ uint8_t RNDIS_QueryRNDISProperty(const uint32_t Oid,
 	struct
 	{
 		RNDIS_Query_Complete_t QueryMessageResponse;
-		uint8_t                ContigiousBuffer[MaxLength];
+		uint8_t                ContiguousBuffer[MaxLength];
 	} QueryMessageResponseData;
 
 	QueryMessage.MessageType    = REMOTE_NDIS_QUERY_MSG;
@@ -265,7 +265,7 @@ uint8_t RNDIS_QueryRNDISProperty(const uint32_t Oid,
 	if (QueryMessageResponseData.QueryMessageResponse.Status != REMOTE_NDIS_STATUS_SUCCESS)
 	  return RNDIS_COMMAND_FAILED;
 
-	memcpy(Buffer, &QueryMessageResponseData.ContigiousBuffer, MaxLength);
+	memcpy(Buffer, &QueryMessageResponseData.ContiguousBuffer, MaxLength);
 
 	return HOST_SENDCONTROL_Successful;
 }

Demos/Host/LowLevel/RNDISEthernetHost/Lib/RNDISCommands.h

@@ -100,7 +100,7 @@
 			uint32_t AFListSize;
 		} RNDIS_Initialize_Complete_t;
 		
-		/** Type define for a RNDIS Keepalive command message. */
+		/** Type define for a RNDIS Keep-alive command message. */
 		typedef struct
 		{
 			uint32_t MessageType;
@@ -108,7 +108,7 @@
 			uint32_t RequestId;
 		} RNDIS_KeepAlive_Message_t;
 
-		/** Type define for a RNDIS Keepalive complete message. */
+		/** Type define for a RNDIS Keep-alive complete message. */
 		typedef struct
 		{
 			uint32_t MessageType;

Demos/Host/LowLevel/RNDISEthernetHost/RNDISHost.txt

@@ -50,7 +50,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Host/LowLevel/StillImageHost/StillImageHost.txt

@@ -52,7 +52,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Demos/Host/LowLevel/VirtualSerialHost/VirtualSerialHost.txt

@@ -53,7 +53,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

LUFA/Common/Common.h

@@ -114,7 +114,7 @@
 
 			#if !defined(pgm_read_ptr) || defined(__DOXYGEN__)
 				/** Reads a pointer out of PROGMEM space. This is currently a wrapper for the avr-libc pgm_read_ptr()
-				 *  macro with a void* cast, so that its value can be assigned diretly to a pointer variable or used
+				 *  macro with a void* cast, so that its value can be assigned directly to a pointer variable or used
 				 *  in pointer arithmetic without further casting in C. In a future avr-libc distribution this will be
 				 *  part of the standard API and will be implemented in a more formal manner.
 				 *

LUFA/DriverStubs/Dataflash.h

@@ -53,7 +53,7 @@
 	/* Private Interface - For use in library only: */
 	#if !defined(__DOXYGEN__)
 		/* Macros: */
-			#define DATAFLASH_CHIPCS_MASK                // TODO: Replace this with a mask of all the /CS pins of all dataflashes
+			#define DATAFLASH_CHIPCS_MASK                // TODO: Replace this with a mask of all the /CS pins of all Dataflashes
 			#define DATAFLASH_CHIPCS_DDR                 // TODO: Replace with the DDR register name for the board's Dataflash ICs
 			#define DATAFLASH_CHIPCS_PORT                // TODO: Replace with the PORT register name for the board's Dataflash ICs
 	#endif
@@ -61,7 +61,7 @@
 	/* Public Interface - May be used in end-application: */
 		/* Macros: */
 			/** Constant indicating the total number of dataflash ICs mounted on the selected board. */
-			#define DATAFLASH_TOTALCHIPS                 // TODO: Replace with the number of dataflashes on the board, max 2
+			#define DATAFLASH_TOTALCHIPS                 // TODO: Replace with the number of Dataflashes on the board, max 2
 
 			/** Mask for no dataflash chip selected. */
 			#define DATAFLASH_NO_CHIP                    DATAFLASH_CHIPCS_MASK

LUFA/Drivers/USB/HighLevel/StdDescriptors.h

@@ -99,7 +99,7 @@
 				#define USE_INTERNAL_SERIAL           NO_DESCRIPTOR
 			#endif
 			
-			/** Macro to calculate the power value for the configuration descriptor, from a given number of milliamps. */
+			/** Macro to calculate the power value for the configuration descriptor, from a given number of milliamperes. */
 			#define USB_CONFIG_POWER_MA(mA)           ((mA) >> 1)
 
 			/** Macro to calculate the Unicode length of a string with a given number of Unicode characters.

LUFA/Drivers/USB/USB.h

@@ -173,8 +173,8 @@
  *
  *  To initialize the Class driver instance, the driver's <i><b>{Class Name}</b>_Device_ConfigureEndpoints()</i> function
  *  should be called in response to the \ref EVENT_USB_Device_ConfigurationChanged() event. This function will return a
- *  boolean value if the driver sucessfully initialized the instance. Like all the class driver functions, this function
+ *  boolean value if the driver successfully initialized the instance. Like all the class driver functions, this function
- *  takes in the address of the specific instance you wish to initialize - in this manner, multiple seperate instances of
+ *  takes in the address of the specific instance you wish to initialize - in this manner, multiple separate instances of
  *  the same class type can be initialized like thus:
  *
  *  \code
@@ -191,7 +191,7 @@
  *  <i><b>{Class Name}</b>_Device_USBTask()</i> function in the main program loop. The exact implementation of this
  *  function varies between class drivers, and can be used for any internal class driver purpose to maintain each
  *  instance. Again, this function uses the address of the instance to operate on, and thus needs to be called for each
- *  seperate instance, just like the main USB maintenance routine \ref USB_USBTask():
+ *  separate instance, just like the main USB maintenance routine \ref USB_USBTask():
  *
  *  \code
  *  int main(void)
@@ -271,9 +271,9 @@
  *  To initialize the Class driver instance, the driver's <i><b>{Class Name}</b>_Host_ConfigurePipes()</i> function
  *  should be called in response to the host state machine entering the \ref HOST_STATE_Addressed state. This function
  *  will return an error code from the class driver's <i><b>{Class Name}</b>_EnumerationFailure_ErrorCodes_t</i> enum
- *  to indicate if the driver sucessfully initialized the instance and bound it to an interface in the attached device.
+ *  to indicate if the driver successfully initialized the instance and bound it to an interface in the attached device.
  *  Like all the class driver functions, this function takes in the address of the specific instance you wish to initialize - 
- *  in this manner, multiple seperate instances of the same class type can be initialized. A fragment of a Class Driver
+ *  in this manner, multiple separate instances of the same class type can be initialized. A fragment of a Class Driver
  *  based Host mode application may look like the following:
  *
  *  \code
@@ -315,7 +315,7 @@
  *  <i><b>{Class Name}</b>_Host_USBTask()</i> function in the main program loop. The exact implementation of this
  *  function varies between class drivers, and can be used for any internal class driver purpose to maintain each
  *  instance. Again, this function uses the address of the instance to operate on, and thus needs to be called for each
- *  seperate instance, just like the main USB maintenance routine \ref USB_USBTask():
+ *  separate instance, just like the main USB maintenance routine \ref USB_USBTask():
  *
  *  \code
  *  int main(void)

LUFA/ManPages/ChangeLog.txt

@@ -36,8 +36,8 @@
   *    minimal loads and stores rather than complicated shifts
   *  - The software UART in the XPLAINBridge has been largely altered to try to improve upon its performance and reliability
   *  - The USBtoSerial and Benito projects now flushes received data via a flush timer, so that several bytes can be transmitted at once
-  *  - Removed the automated checking of event names in the demo, project and bootloader makefiles due to inconsistancies between the
+  *  - Removed the automated checking of event names in the demo, project and bootloader makefiles due to inconsistencies between the
-  *    behaviour of the command line tools used to perform the check on each platform
+  *    behavior of the command line tools used to perform the check on each platform
   *  - Internal USB driver source files renamed and moved to ease future possible architecture ports
   *  - All internal pseudo-function macros have been converted to true inline functions for type-safety and readability
   *  - Changed LED indicator masks for the AVRISP-MKII project, so that there are defined roles for each LED
@@ -425,7 +425,7 @@
   *    internal control
   *  - Interrupts are no longer disabled during the processing of Control Requests on the default endpoint while in device mode
   *  - AudioOutput demos now always output to board LEDs, regardless of output mode (removed AUDIO_OUT_LEDS project option)
-  *  - Removed SINGLE_DEVICE_CONFIGURATION compile time option in favour of the new FIXED_NUM_CONFIGURATIONS option so that the exact number
+  *  - Removed SINGLE_DEVICE_CONFIGURATION compile time option in favor of the new FIXED_NUM_CONFIGURATIONS option so that the exact number
   *    of device configurations can be defined statically
   *  - Removed VBUS events, as they are already exposed to the user application via the regular device connection and disconnection events
   *  - Renamed and altered existing events to properly separate out Host and Device mode events
@@ -513,7 +513,7 @@
   *    pipes can be used with the function
   *  - The USB Host management task now saves and restores the currently selected pipe before and after the task completes
   *  - Fixed GenericHIDHost demo report write routine incorrect for control type requests (thanks to Andrei Krainev)
-  *  - Removed Endpoint_ClearCurrentBank() and Pipe_ClearCurrentBank() in favour of new Endpoint_ClearIN(), Endpoint_ClearOUT(),
+  *  - Removed Endpoint_ClearCurrentBank() and Pipe_ClearCurrentBank() in favor of new Endpoint_ClearIN(), Endpoint_ClearOUT(),
   *    Pipe_ClearIN() and Pipe_ClearOUT() macros (done to allow for the detection of packets of zero length)
   *  - Renamed *_ReadWriteAllowed() macros to *_IsReadWriteAllowed() to remain consistent with the rest of the LUFA API
   *  - Endpoint_IsSetupReceived() macro has been renamed to Endpoint_IsSETUPReceived(), Endpoint_ClearSetupReceived() macro has been
@@ -540,7 +540,7 @@
   *  - Changed over all deprecated GCC structure tag initializers to the standardized C99 format (thanks to Mike Alexander)
   *  - USB_HostRequest renamed to USB_ControlRequest, entire control request header is now read into USB_ControlRequest in Device mode
   *    rather than having the library pass only partially read header data to the application
-  *  - The USB_UnhandledControlPacket event has had its parameters removed, in favour of accessing the new USB_ControlRequest structure
+  *  - The USB_UnhandledControlPacket event has had its parameters removed, in favor of accessing the new USB_ControlRequest structure
   *  - The Endpoint control stream functions now correctly send a ZLP to the host when less data than requested is sent
   *  - Fixed USB_RemoteWakeupEnabled flag never being set (the REMOTE WAKEUP Set Feature request was not being handled)
   *  - Renamed the FEATURELESS_CONTROL_ONLY_DEVICE compile-time token to CONTROL_ONLY_DEVICE
@@ -747,7 +747,7 @@
   *
   *  - Fixed SwapEndian_32() function in Common.h so that it now works correctly (wrong parameter types)
   *  - Updated RNDIS demo - notification endpoint is no longer blocking so that it works with faulty Linux RNDIS
-  *    implementations (where the notification endpoint is ignored in favour of polling the control endpoint)
+  *    implementations (where the notification endpoint is ignored in favor of polling the control endpoint)
   *  - Fixed incorrect Vendor Description string return size in RNDIS demo for the OID_GEN_VENDOR_DESCRIPTION OID token
   *  - Added very basic TCP/IP stack and HTTP/TELNET servers to RNDIS demo
   *  - Fixed DFU bootloader exit causing programming software to complain about failed writes
@@ -880,7 +880,7 @@
   *  - Separated out SPI code into new SPI driver in AT90USBXXX driver directory
   *  - Bootloader now returns correct PID for the selected USB AVR model, not just the AT90USB128X PID
   *  - Added support for the RZUSBSTICK board
-  *  - Bicolour driver removed in favour of generic LEDs driver
+  *  - Bicolour driver removed in favor of generic LEDs driver
   *  - Added support for the ATMEGA32U4 AVR
   *  - Added MANUAL_PLL_CONTROL compile time option to prevent the USB library from manipulating the PLL
   *

LUFA/ManPages/LUFAvsAtmelStack.txt

@@ -18,7 +18,7 @@
  *
  *  - <b>Demos and Projects:</b>
  *    Unlike the Atmel stack, LUFA comes with many different Device and Host mode Demos and Projects ready to run out of the box.
- *    Atmel favours separate downloads for each of their (small set) of USB AVR demos, which requires more time and offers less
+ *    Atmel favors separate downloads for each of their (small set) of USB AVR demos, which requires more time and offers less
  *    to the end-user. LUFA also contains several open source Bootloaders, which can be modified as the user wishes to suit his or
  *    her application, instead of being forced to use Atmel's single prebuilt (closed-source) DFU bootloader.
  *

LUFA/ManPages/SoftwareBootloaderJump.txt

@@ -44,7 +44,7 @@
  *
  *  void Jump_To_Bootloader(void)
  *  {
- *      // If USB is used, detatch from the bus
+ *      // If USB is used, detach from the bus
  *      USB_ShutDown();
  *
  *      // Disable all interrupts

Projects/AVRISP-MKII/AVRISP-MKII.txt

@@ -55,7 +55,7 @@
  *
  *  Note that this design currently has the following limitations:
  *    - No reversed/shorted target connector detection and notification
- *    - A seperate header is required for each of the ISP, PDI and TPI programming protocols that the user wishes to use
+ *    - A separate header is required for each of the ISP, PDI and TPI programming protocols that the user wishes to use
  *
  *  On AVR models with an ADC converter, AVCC should be tied to 5V (e.g. VBUS) and the VTARGET_ADC_CHANNEL token should be
  *  set to an appropriate ADC channel number in the project makefile for VTARGET detection to operate correctly. On models
@@ -203,7 +203,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this project, which can control the project behaviour when defined, or changed in value.
+ *  The following defines can be found in this project, which can control the project behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Projects/Benito/Benito.txt

@@ -58,7 +58,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this project, which can control the project behaviour when defined, or changed in value.
+ *  The following defines can be found in this project, which can control the project behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>
@@ -94,7 +94,7 @@
  *   <tr>
  *    <td>PING_PONG_LED_PULSE_MS</td>
  *    <td>Makefile LUFA_OPTS</td>
- *    <td>Pulse length in milliseconds for the enumeration LED ping-poning between toggles.</td>
+ *    <td>Pulse length in milliseconds for the enumeration LED ping-ponging between toggles.</td>
  *   </tr>
  *   <tr>
  *    <td>RECEIVE_BUFFER_FLUSH_MS</td>

Projects/Incomplete/MIDIToneGenerator/MIDIToneGenerator.c

@@ -149,7 +149,7 @@ void SetupHardware(void)
 
 	/* PWM speaker timer initialization */
 	TCCR3A  = ((1 << WGM30) | (1 << COM3A1) | (1 << COM3A0)); // Set on match, clear on TOP
-	TCCR3B  = ((1 << WGM32) | (1 << CS30));  // Fast 8-Bit PWM, Fcpu speed
+	TCCR3B  = ((1 << WGM32) | (1 << CS30));  // Fast 8-Bit PWM, F_CPU speed
 }
 
 /** Event handler for the library USB Connection event. */

Projects/Incomplete/StandaloneProgrammer/Lib/DataflashManager.c

@@ -30,7 +30,7 @@
 
 /** \file
  *
- *  Functions to manage the physical dataflash media, including reading and writing of
+ *  Functions to manage the physical Dataflash media, including reading and writing of
  *  blocks of data. These functions are called by the SCSI layer when data must be stored
  *  or retrieved to/from the physical storage media. If a different media is used (such
  *  as a SD card or EEPROM), functions similar to these will need to be generated.
@@ -40,9 +40,9 @@
 #include "DataflashManager.h"
 
 #if defined(USB_CAN_BE_DEVICE)
-/** Writes blocks (OS blocks, not Dataflash pages) to the storage medium, the board dataflash IC(s), from
+/** Writes blocks (OS blocks, not Dataflash pages) to the storage medium, the board Dataflash IC(s), from
  *  the pre-selected data OUT endpoint. This routine reads in OS sized blocks from the endpoint and writes
- *  them to the dataflash in Dataflash page sized blocks.
+ *  them to the Dataflash in Dataflash page sized blocks.
  *
  *  \param[in] MSInterfaceInfo  Pointer to a structure containing a Mass Storage Class configuration and state
  *  \param[in] BlockAddress  Data block starting address for the write sequence
@@ -61,13 +61,13 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 	Dataflash_SelectChipFromPage(CurrDFPage);
 
 #if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
-	/* Copy selected dataflash's current page contents to the dataflash buffer */
+	/* Copy selected dataflash's current page contents to the Dataflash buffer */
 	Dataflash_SendByte(DF_CMD_MAINMEMTOBUFF1);
 	Dataflash_SendAddressBytes(CurrDFPage, 0);
 	Dataflash_WaitWhileBusy();
 #endif
 
-	/* Send the dataflash buffer write command */
+	/* Send the Dataflash buffer write command */
 	Dataflash_SendByte(DF_CMD_BUFF1WRITE);
 	Dataflash_SendAddressBytes(0, CurrDFPageByte);
 
@@ -79,7 +79,7 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 	{
 		uint8_t BytesInBlockDiv16 = 0;
 		
-		/* Write an endpoint packet sized data block to the dataflash */
+		/* Write an endpoint packet sized data block to the Dataflash */
 		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
 		{
 			/* Check if the endpoint is currently empty */
@@ -93,30 +93,30 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 				  return;
 			}
 
-			/* Check if end of dataflash page reached */
+			/* Check if end of Dataflash page reached */
 			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
 			{
-				/* Write the dataflash buffer contents back to the dataflash page */
+				/* Write the Dataflash buffer contents back to the Dataflash page */
 				Dataflash_WaitWhileBusy();
 				Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);
 				Dataflash_SendAddressBytes(CurrDFPage, 0);
 
-				/* Reset the dataflash buffer counter, increment the page counter */
+				/* Reset the Dataflash buffer counter, increment the page counter */
 				CurrDFPageByteDiv16 = 0;
 				CurrDFPage++;
 
-				/* Once all the dataflash ICs have had their first buffers filled, switch buffers to maintain throughput */
+				/* Once all the Dataflash ICs have had their first buffers filled, switch buffers to maintain throughput */
 				if (Dataflash_GetSelectedChip() == DATAFLASH_CHIP_MASK(DATAFLASH_TOTALCHIPS))
 				  UsingSecondBuffer = !(UsingSecondBuffer);
 
-				/* Select the next dataflash chip based on the new dataflash page index */
+				/* Select the next Dataflash chip based on the new Dataflash page index */
 				Dataflash_SelectChipFromPage(CurrDFPage);
 
 #if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
-				/* If less than one dataflash page remaining, copy over the existing page to preserve trailing data */
+				/* If less than one Dataflash page remaining, copy over the existing page to preserve trailing data */
 				if ((TotalBlocks * (VIRTUAL_MEMORY_BLOCK_SIZE >> 4)) < (DATAFLASH_PAGE_SIZE >> 4))
 				{
-					/* Copy selected dataflash's current page contents to the dataflash buffer */
+					/* Copy selected dataflash's current page contents to the Dataflash buffer */
 					Dataflash_WaitWhileBusy();
 					Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_MAINMEMTOBUFF2 : DF_CMD_MAINMEMTOBUFF1);
 					Dataflash_SendAddressBytes(CurrDFPage, 0);
@@ -124,12 +124,12 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 				}
 #endif
 
-				/* Send the dataflash buffer write command */
+				/* Send the Dataflash buffer write command */
 				Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2WRITE : DF_CMD_BUFF1WRITE);
 				Dataflash_SendAddressBytes(0, 0);				
 			}
 
-			/* Write one 16-byte chunk of data to the dataflash */
+			/* Write one 16-byte chunk of data to the Dataflash */
 			Dataflash_SendByte(Endpoint_Read_Byte());
 			Dataflash_SendByte(Endpoint_Read_Byte());
 			Dataflash_SendByte(Endpoint_Read_Byte());
@@ -147,7 +147,7 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 			Dataflash_SendByte(Endpoint_Read_Byte());
 			Dataflash_SendByte(Endpoint_Read_Byte());
 			
-			/* Increment the dataflash page 16 byte block counter */
+			/* Increment the Dataflash page 16 byte block counter */
 			CurrDFPageByteDiv16++;
 
 			/* Increment the block 16 byte block counter */
@@ -162,7 +162,7 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 		TotalBlocks--;
 	}
 
-	/* Write the dataflash buffer contents back to the dataflash page */
+	/* Write the Dataflash buffer contents back to the Dataflash page */
 	Dataflash_WaitWhileBusy();
 	Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);
 	Dataflash_SendAddressBytes(CurrDFPage, 0x00);
@@ -172,11 +172,11 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 	if (!(Endpoint_IsReadWriteAllowed()))
 	  Endpoint_ClearOUT();
 
-	/* Deselect all dataflash chips */
+	/* Deselect all Dataflash chips */
 	Dataflash_DeselectChip();
 }
 
-/** Reads blocks (OS blocks, not Dataflash pages) from the storage medium, the board dataflash IC(s), into
+/** Reads blocks (OS blocks, not Dataflash pages) from the storage medium, the board Dataflash IC(s), into
  *  the pre-selected data IN endpoint. This routine reads in Dataflash page sized blocks from the Dataflash
  *  and writes them in OS sized blocks to the endpoint.
  *
@@ -195,7 +195,7 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 	/* Select the correct starting Dataflash IC for the block requested */
 	Dataflash_SelectChipFromPage(CurrDFPage);
 
-	/* Send the dataflash main memory page read command */
+	/* Send the Dataflash main memory page read command */
 	Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
 	Dataflash_SendAddressBytes(CurrDFPage, CurrDFPageByte);
 	Dataflash_SendByte(0x00);
@@ -211,7 +211,7 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 	{
 		uint8_t BytesInBlockDiv16 = 0;
 		
-		/* Write an endpoint packet sized data block to the dataflash */
+		/* Write an endpoint packet sized data block to the Dataflash */
 		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
 		{
 			/* Check if the endpoint is currently full */
@@ -225,17 +225,17 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 				  return;
 			}
 			
-			/* Check if end of dataflash page reached */
+			/* Check if end of Dataflash page reached */
 			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
 			{
-				/* Reset the dataflash buffer counter, increment the page counter */
+				/* Reset the Dataflash buffer counter, increment the page counter */
 				CurrDFPageByteDiv16 = 0;
 				CurrDFPage++;
 
-				/* Select the next dataflash chip based on the new dataflash page index */
+				/* Select the next Dataflash chip based on the new Dataflash page index */
 				Dataflash_SelectChipFromPage(CurrDFPage);
 				
-				/* Send the dataflash main memory page read command */
+				/* Send the Dataflash main memory page read command */
 				Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
 				Dataflash_SendAddressBytes(CurrDFPage, 0);
 				Dataflash_SendByte(0x00);
@@ -244,7 +244,7 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 				Dataflash_SendByte(0x00);
 			}	
 
-			/* Read one 16-byte chunk of data from the dataflash */
+			/* Read one 16-byte chunk of data from the Dataflash */
 			Endpoint_Write_Byte(Dataflash_ReceiveByte());
 			Endpoint_Write_Byte(Dataflash_ReceiveByte());
 			Endpoint_Write_Byte(Dataflash_ReceiveByte());
@@ -262,7 +262,7 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 			Endpoint_Write_Byte(Dataflash_ReceiveByte());
 			Endpoint_Write_Byte(Dataflash_ReceiveByte());
 			
-			/* Increment the dataflash page 16 byte block counter */
+			/* Increment the Dataflash page 16 byte block counter */
 			CurrDFPageByteDiv16++;
 			
 			/* Increment the block 16 byte block counter */
@@ -281,14 +281,14 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 	if (!(Endpoint_IsReadWriteAllowed()))
 	  Endpoint_ClearIN();
 
-	/* Deselect all dataflash chips */
+	/* Deselect all Dataflash chips */
 	Dataflash_DeselectChip();
 }
 
-/** Writes blocks (OS blocks, not Dataflash pages) to the storage medium, the board dataflash IC(s), from
+/** Writes blocks (OS blocks, not Dataflash pages) to the storage medium, the board Dataflash IC(s), from
  *  the a given RAM buffer. This routine reads in OS sized blocks from the buffer and writes them to the
- *  dataflash in Dataflash page sized blocks. This can be linked to FAT libraries to write files to the
+ *  Dataflash in Dataflash page sized blocks. This can be linked to FAT libraries to write files to the
- *  dataflash.
+ *  Dataflash.
  *
  *  \param[in] BlockAddress  Data block starting address for the write sequence
  *  \param[in] TotalBlocks   Number of blocks of data to write
@@ -307,13 +307,13 @@ void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress,
 	Dataflash_SelectChipFromPage(CurrDFPage);
 
 #if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
-	/* Copy selected dataflash's current page contents to the dataflash buffer */
+	/* Copy selected dataflash's current page contents to the Dataflash buffer */
 	Dataflash_SendByte(DF_CMD_MAINMEMTOBUFF1);
 	Dataflash_SendAddressBytes(CurrDFPage, 0);
 	Dataflash_WaitWhileBusy();
 #endif
 
-	/* Send the dataflash buffer write command */
+	/* Send the Dataflash buffer write command */
 	Dataflash_SendByte(DF_CMD_BUFF1WRITE);
 	Dataflash_SendAddressBytes(0, CurrDFPageByte);
 	
@@ -321,33 +321,33 @@ void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress,
 	{
 		uint8_t BytesInBlockDiv16 = 0;
 		
-		/* Write an endpoint packet sized data block to the dataflash */
+		/* Write an endpoint packet sized data block to the Dataflash */
 		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
 		{
-			/* Check if end of dataflash page reached */
+			/* Check if end of Dataflash page reached */
 			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
 			{
-				/* Write the dataflash buffer contents back to the dataflash page */
+				/* Write the Dataflash buffer contents back to the Dataflash page */
 				Dataflash_WaitWhileBusy();
 				Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);
 				Dataflash_SendAddressBytes(CurrDFPage, 0);
 
-				/* Reset the dataflash buffer counter, increment the page counter */
+				/* Reset the Dataflash buffer counter, increment the page counter */
 				CurrDFPageByteDiv16 = 0;
 				CurrDFPage++;
 
-				/* Once all the dataflash ICs have had their first buffers filled, switch buffers to maintain throughput */
+				/* Once all the Dataflash ICs have had their first buffers filled, switch buffers to maintain throughput */
 				if (Dataflash_GetSelectedChip() == DATAFLASH_CHIP_MASK(DATAFLASH_TOTALCHIPS))
 				  UsingSecondBuffer = !(UsingSecondBuffer);
 
-				/* Select the next dataflash chip based on the new dataflash page index */
+				/* Select the next Dataflash chip based on the new Dataflash page index */
 				Dataflash_SelectChipFromPage(CurrDFPage);
 
 #if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
-				/* If less than one dataflash page remaining, copy over the existing page to preserve trailing data */
+				/* If less than one Dataflash page remaining, copy over the existing page to preserve trailing data */
 				if ((TotalBlocks * (VIRTUAL_MEMORY_BLOCK_SIZE >> 4)) < (DATAFLASH_PAGE_SIZE >> 4))
 				{
-					/* Copy selected dataflash's current page contents to the dataflash buffer */
+					/* Copy selected dataflash's current page contents to the Dataflash buffer */
 					Dataflash_WaitWhileBusy();
 					Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_MAINMEMTOBUFF2 : DF_CMD_MAINMEMTOBUFF1);
 					Dataflash_SendAddressBytes(CurrDFPage, 0);
@@ -355,17 +355,17 @@ void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress,
 				}
 #endif
 
-				/* Send the dataflash buffer write command */
+				/* Send the Dataflash buffer write command */
 				Dataflash_ToggleSelectedChipCS();
 				Dataflash_SendByte(DF_CMD_BUFF1WRITE);
 				Dataflash_SendAddressBytes(0, 0);
 			}
 			
-			/* Write one 16-byte chunk of data to the dataflash */
+			/* Write one 16-byte chunk of data to the Dataflash */
 			for (uint8_t ByteNum = 0; ByteNum < 16; ByteNum++)
 			  Dataflash_SendByte(*(BufferPtr++));
 			
-			/* Increment the dataflash page 16 byte block counter */
+			/* Increment the Dataflash page 16 byte block counter */
 			CurrDFPageByteDiv16++;
 
 			/* Increment the block 16 byte block counter */
@@ -376,20 +376,20 @@ void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress,
 		TotalBlocks--;
 	}
 
-	/* Write the dataflash buffer contents back to the dataflash page */
+	/* Write the Dataflash buffer contents back to the Dataflash page */
 	Dataflash_WaitWhileBusy();
 	Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);
 	Dataflash_SendAddressBytes(CurrDFPage, 0x00);
 	Dataflash_WaitWhileBusy();
 
-	/* Deselect all dataflash chips */
+	/* Deselect all Dataflash chips */
 	Dataflash_DeselectChip();
 }
 
-/** Reads blocks (OS blocks, not Dataflash pages) from the storage medium, the board dataflash IC(s), into
+/** Reads blocks (OS blocks, not Dataflash pages) from the storage medium, the board Dataflash IC(s), into
  *  the a preallocated RAM buffer. This routine reads in Dataflash page sized blocks from the Dataflash
  *  and writes them in OS sized blocks to the given buffer. This can be linked to FAT libraries to read
- *  the files stored on the dataflash.
+ *  the files stored on the Dataflash.
  *
  *  \param[in] BlockAddress  Data block starting address for the read sequence
  *  \param[in] TotalBlocks   Number of blocks of data to read
@@ -406,7 +406,7 @@ void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress,
 	/* Select the correct starting Dataflash IC for the block requested */
 	Dataflash_SelectChipFromPage(CurrDFPage);
 
-	/* Send the dataflash main memory page read command */
+	/* Send the Dataflash main memory page read command */
 	Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
 	Dataflash_SendAddressBytes(CurrDFPage, CurrDFPageByte);
 	Dataflash_SendByte(0x00);
@@ -418,20 +418,20 @@ void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress,
 	{
 		uint8_t BytesInBlockDiv16 = 0;
 		
-		/* Write an endpoint packet sized data block to the dataflash */
+		/* Write an endpoint packet sized data block to the Dataflash */
 		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
 		{
-			/* Check if end of dataflash page reached */
+			/* Check if end of Dataflash page reached */
 			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
 			{
-				/* Reset the dataflash buffer counter, increment the page counter */
+				/* Reset the Dataflash buffer counter, increment the page counter */
 				CurrDFPageByteDiv16 = 0;
 				CurrDFPage++;
 
-				/* Select the next dataflash chip based on the new dataflash page index */
+				/* Select the next Dataflash chip based on the new Dataflash page index */
 				Dataflash_SelectChipFromPage(CurrDFPage);
 				
-				/* Send the dataflash main memory page read command */
+				/* Send the Dataflash main memory page read command */
 				Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
 				Dataflash_SendAddressBytes(CurrDFPage, 0);
 				Dataflash_SendByte(0x00);
@@ -440,11 +440,11 @@ void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress,
 				Dataflash_SendByte(0x00);
 			}	
 
-			/* Read one 16-byte chunk of data from the dataflash */
+			/* Read one 16-byte chunk of data from the Dataflash */
 			for (uint8_t ByteNum = 0; ByteNum < 16; ByteNum++)
 			  *(BufferPtr++) = Dataflash_ReceiveByte();
 			
-			/* Increment the dataflash page 16 byte block counter */
+			/* Increment the Dataflash page 16 byte block counter */
 			CurrDFPageByteDiv16++;
 			
 			/* Increment the block 16 byte block counter */
@@ -455,14 +455,14 @@ void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress,
 		TotalBlocks--;
 	}
 
-	/* Deselect all dataflash chips */
+	/* Deselect all Dataflash chips */
 	Dataflash_DeselectChip();
 }
 
-/** Disables the dataflash memory write protection bits on the board Dataflash ICs, if enabled. */
+/** Disables the Dataflash memory write protection bits on the board Dataflash ICs, if enabled. */
 void DataflashManager_ResetDataflashProtections(void)
 {
-	/* Select first dataflash chip, send the read status register command */
+	/* Select first Dataflash chip, send the read status register command */
 	Dataflash_SelectChip(DATAFLASH_CHIP1);
 	Dataflash_SendByte(DF_CMD_GETSTATUS);
 	
@@ -478,7 +478,7 @@ void DataflashManager_ResetDataflashProtections(void)
 		Dataflash_SendByte(DF_CMD_SECTORPROTECTIONOFF[3]);
 	}
 	
-	/* Select second dataflash chip (if present on selected board), send read status register command */
+	/* Select second Dataflash chip (if present on selected board), send read status register command */
 	#if (DATAFLASH_TOTALCHIPS == 2)
 	Dataflash_SelectChip(DATAFLASH_CHIP2);
 	Dataflash_SendByte(DF_CMD_GETSTATUS);
@@ -496,7 +496,7 @@ void DataflashManager_ResetDataflashProtections(void)
 	}
 	#endif
 	
-	/* Deselect current dataflash chip */
+	/* Deselect current Dataflash chip */
 	Dataflash_DeselectChip();
 }
 

Projects/Incomplete/StandaloneProgrammer/Lib/PetiteFATFs/diskio.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------------------------------------
-/  PFF - Low level disk interface modlue include file    (C)ChaN, 2010
+/  PFF - Low level disk interface module include file    (C)ChaN, 2010
 /-----------------------------------------------------------------------*/
 
 #ifndef _DISKIO
@@ -15,7 +15,7 @@ typedef BYTE	DSTATUS;
 typedef enum {
 	RES_OK = 0,		/* 0: Function succeeded */
 	RES_ERROR,		/* 1: Disk error */
-	RES_STRERR,		/* 2: Seream error */
+	RES_STRERR,		/* 2: Stream error */
 	RES_NOTRDY,		/* 3: Not ready */
 	RES_PARERR		/* 4: Invalid parameter */
 } DRESULT;

Projects/Incomplete/StandaloneProgrammer/Lib/PetiteFATFs/pff.c

@@ -3,7 +3,7 @@
 /-----------------------------------------------------------------------------/
 / Petit FatFs module is an open source software to implement FAT file system to
 / small embedded systems. This is a free software and is opened for education,
-/ research and commercial developments under license policy of following trems.
+/ research and commercial developments under license policy of following terms.
 /
 /  Copyright (C) 2010, ChaN, all right reserved.
 /
@@ -106,7 +106,7 @@ CLUST get_fat (	/* 1:IO error, Else:Cluster status */
 #endif
 	}
 
-	return 1;	/* An error occured at the disk I/O layer */
+	return 1;	/* An error occurred at the disk I/O layer */
 }
 
 
@@ -167,7 +167,7 @@ FRESULT dir_rewind (
 /*-----------------------------------------------------------------------*/
 
 static
-FRESULT dir_next (	/* FR_OK:Succeeded, FR_NO_FILE:End of table, FR_DENIED:EOT and could not streach */
+FRESULT dir_next (	/* FR_OK:Succeeded, FR_NO_FILE:End of table, FR_DENIED:EOT and could not stretch */
 	DIR *dj			/* Pointer to directory object */
 )
 {
@@ -310,7 +310,7 @@ FRESULT create_name (
 		sfn[i++] = c;
 	}
 	if (!i) return FR_INVALID_NAME;		/* Reject null string */
-	*path = &p[si];						/* Rerurn pointer to the next segment */
+	*path = &p[si];						/* Rerun pointer to the next segment */
 
 	sfn[11] = (c < ' ') ? 1 : 0;		/* Set last segment flag if end of path */
 
@@ -448,7 +448,7 @@ BYTE check_fs (	/* 0:The FAT boot record, 1:Valid boot record but not an FAT, 2:
 
 
 /*-----------------------------------------------------------------------*/
-/* Mount/Unmount a Locical Drive                                         */
+/* Mount/Unmount a Logical Drive                                         */
 /*-----------------------------------------------------------------------*/
 
 FRESULT pf_mount (
@@ -480,7 +480,7 @@ FRESULT pf_mount (
 		}
 	}
 	if (fmt == 3) return FR_DISK_ERR;
-	if (fmt) return FR_NO_FILESYSTEM;	/* No valid FAT patition is found */
+	if (fmt) return FR_NO_FILESYSTEM;	/* No valid FAT partition is found */
 
 	/* Initialize the file system object */
 	if (disk_readp(buf, bsect, 13, sizeof(buf))) return FR_DISK_ERR;
@@ -491,7 +491,7 @@ FRESULT pf_mount (
 	fsize *= buf[BPB_NumFATs-13];						/* Number of sectors in FAT area */
 	fs->fatbase = bsect + LD_WORD(buf+BPB_RsvdSecCnt-13); /* FAT start sector (lba) */
 	fs->csize = buf[BPB_SecPerClus-13];					/* Number of sectors per cluster */
-	fs->n_rootdir = LD_WORD(buf+BPB_RootEntCnt-13);		/* Nmuber of root directory entries */
+	fs->n_rootdir = LD_WORD(buf+BPB_RootEntCnt-13);		/* Number of root directory entries */
 	tsect = LD_WORD(buf+BPB_TotSec16-13);				/* Number of sectors on the file system */
 	if (!tsect) tsect = LD_DWORD(buf+BPB_TotSec32-13);
 	mclst = (tsect						/* Last cluster# + 1 */
@@ -688,7 +688,7 @@ FRESULT pf_lseek (
 
 #if _USE_DIR
 /*-----------------------------------------------------------------------*/
-/* Create a Directroy Object                                             */
+/* Create a Directory Object                                             */
 /*-----------------------------------------------------------------------*/
 
 FRESULT pf_opendir (
@@ -733,7 +733,7 @@ FRESULT pf_opendir (
 
 
 /*-----------------------------------------------------------------------*/
-/* Read Directory Entry in Sequense                                      */
+/* Read Directory Entry in Sequence                                      */
 /*-----------------------------------------------------------------------*/
 
 FRESULT pf_readdir (

Projects/Incomplete/StandaloneProgrammer/Lib/SCSI.c

@@ -242,7 +242,7 @@ static void SCSI_Command_Send_Diagnostic(USB_ClassInfo_MS_Device_t* const MSInte
 }
 
 /** Command processing for an issued SCSI READ (10) or WRITE (10) command. This command reads in the block start address
- *  and total number of blocks to process, then calls the appropriate low-level dataflash routine to handle the actual
+ *  and total number of blocks to process, then calls the appropriate low-level Dataflash routine to handle the actual
  *  reading and writing of the data.
  *
  *  \param[in] MSInterfaceInfo  Pointer to the Mass Storage class interface structure that the command is associated with

Projects/Incomplete/StandaloneProgrammer/StandaloneProgrammer.c

@@ -40,7 +40,7 @@
 /** Standard file stream for the currently open file on the disk. */
 FILE DiskStream = FDEV_SETUP_STREAM(NULL, Disk_getchar, _FDEV_SETUP_READ);
 
-/** Petite FAT Fs structure to hold the internal state of the FAT driver for the dataflash contents. */
+/** Petite FAT Fs structure to hold the internal state of the FAT driver for the Dataflash contents. */
 FATFS DiskFATState;
 
 /** Stream character fetching routine for the FAT driver so that characters from the currently open file can be
@@ -68,7 +68,7 @@ void EVENT_USB_UIDChange(void)
 #endif
 
 /** Task to determine if the user is wishes to start the programming sequence, and if so executes the 
- *  required functions to program the attached target (if any) with the files loaded to the dataflash.
+ *  required functions to program the attached target (if any) with the files loaded to the Dataflash.
  */
 void Programmer_Task(void)
 {

Projects/LEDNotifier/LEDNotifier.txt

@@ -50,7 +50,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this project, which can control the project behaviour when defined, or changed in value.
+ *  The following defines can be found in this project, which can control the project behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Projects/Magstripe/Magstripe.txt

@@ -97,7 +97,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this project, which can control the project behaviour when defined, or changed in value.
+ *  The following defines can be found in this project, which can control the project behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Projects/MissileLauncher/MissileLauncher.txt

@@ -47,7 +47,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this project, which can control the project behaviour when defined, or changed in value.
+ *  The following defines can be found in this project, which can control the project behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Projects/TempDataLogger/Lib/DataflashManager.c

@@ -30,7 +30,7 @@
 
 /** \file
  *
- *  Functions to manage the physical dataflash media, including reading and writing of
+ *  Functions to manage the physical Dataflash media, including reading and writing of
  *  blocks of data. These functions are called by the SCSI layer when data must be stored
  *  or retrieved to/from the physical storage media. If a different media is used (such
  *  as a SD card or EEPROM), functions similar to these will need to be generated.
@@ -39,9 +39,9 @@
 #define  INCLUDE_FROM_DATAFLASHMANAGER_C
 #include "DataflashManager.h"
 
-/** Writes blocks (OS blocks, not Dataflash pages) to the storage medium, the board dataflash IC(s), from
+/** Writes blocks (OS blocks, not Dataflash pages) to the storage medium, the board Dataflash IC(s), from
  *  the pre-selected data OUT endpoint. This routine reads in OS sized blocks from the endpoint and writes
- *  them to the dataflash in Dataflash page sized blocks.
+ *  them to the Dataflash in Dataflash page sized blocks.
  *
  *  \param[in] MSInterfaceInfo  Pointer to a structure containing a Mass Storage Class configuration and state
  *  \param[in] BlockAddress  Data block starting address for the write sequence
@@ -60,13 +60,13 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 	Dataflash_SelectChipFromPage(CurrDFPage);
 
 #if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
-	/* Copy selected dataflash's current page contents to the dataflash buffer */
+	/* Copy selected dataflash's current page contents to the Dataflash buffer */
 	Dataflash_SendByte(DF_CMD_MAINMEMTOBUFF1);
 	Dataflash_SendAddressBytes(CurrDFPage, 0);
 	Dataflash_WaitWhileBusy();
 #endif
 
-	/* Send the dataflash buffer write command */
+	/* Send the Dataflash buffer write command */
 	Dataflash_SendByte(DF_CMD_BUFF1WRITE);
 	Dataflash_SendAddressBytes(0, CurrDFPageByte);
 
@@ -78,7 +78,7 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 	{
 		uint8_t BytesInBlockDiv16 = 0;
 		
-		/* Write an endpoint packet sized data block to the dataflash */
+		/* Write an endpoint packet sized data block to the Dataflash */
 		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
 		{
 			/* Check if the endpoint is currently empty */
@@ -92,30 +92,30 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 				  return;
 			}
 
-			/* Check if end of dataflash page reached */
+			/* Check if end of Dataflash page reached */
 			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
 			{
-				/* Write the dataflash buffer contents back to the dataflash page */
+				/* Write the Dataflash buffer contents back to the Dataflash page */
 				Dataflash_WaitWhileBusy();
 				Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);
 				Dataflash_SendAddressBytes(CurrDFPage, 0);
 
-				/* Reset the dataflash buffer counter, increment the page counter */
+				/* Reset the Dataflash buffer counter, increment the page counter */
 				CurrDFPageByteDiv16 = 0;
 				CurrDFPage++;
 
-				/* Once all the dataflash ICs have had their first buffers filled, switch buffers to maintain throughput */
+				/* Once all the Dataflash ICs have had their first buffers filled, switch buffers to maintain throughput */
 				if (Dataflash_GetSelectedChip() == DATAFLASH_CHIP_MASK(DATAFLASH_TOTALCHIPS))
 				  UsingSecondBuffer = !(UsingSecondBuffer);
 
-				/* Select the next dataflash chip based on the new dataflash page index */
+				/* Select the next Dataflash chip based on the new Dataflash page index */
 				Dataflash_SelectChipFromPage(CurrDFPage);
 
 #if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
-				/* If less than one dataflash page remaining, copy over the existing page to preserve trailing data */
+				/* If less than one Dataflash page remaining, copy over the existing page to preserve trailing data */
 				if ((TotalBlocks * (VIRTUAL_MEMORY_BLOCK_SIZE >> 4)) < (DATAFLASH_PAGE_SIZE >> 4))
 				{
-					/* Copy selected dataflash's current page contents to the dataflash buffer */
+					/* Copy selected dataflash's current page contents to the Dataflash buffer */
 					Dataflash_WaitWhileBusy();
 					Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_MAINMEMTOBUFF2 : DF_CMD_MAINMEMTOBUFF1);
 					Dataflash_SendAddressBytes(CurrDFPage, 0);
@@ -123,12 +123,12 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 				}
 #endif
 
-				/* Send the dataflash buffer write command */
+				/* Send the Dataflash buffer write command */
 				Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2WRITE : DF_CMD_BUFF1WRITE);
 				Dataflash_SendAddressBytes(0, 0);				
 			}
 
-			/* Write one 16-byte chunk of data to the dataflash */
+			/* Write one 16-byte chunk of data to the Dataflash */
 			Dataflash_SendByte(Endpoint_Read_Byte());
 			Dataflash_SendByte(Endpoint_Read_Byte());
 			Dataflash_SendByte(Endpoint_Read_Byte());
@@ -146,7 +146,7 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 			Dataflash_SendByte(Endpoint_Read_Byte());
 			Dataflash_SendByte(Endpoint_Read_Byte());
 			
-			/* Increment the dataflash page 16 byte block counter */
+			/* Increment the Dataflash page 16 byte block counter */
 			CurrDFPageByteDiv16++;
 
 			/* Increment the block 16 byte block counter */
@@ -161,7 +161,7 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 		TotalBlocks--;
 	}
 
-	/* Write the dataflash buffer contents back to the dataflash page */
+	/* Write the Dataflash buffer contents back to the Dataflash page */
 	Dataflash_WaitWhileBusy();
 	Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);
 	Dataflash_SendAddressBytes(CurrDFPage, 0x00);
@@ -171,11 +171,11 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 	if (!(Endpoint_IsReadWriteAllowed()))
 	  Endpoint_ClearOUT();
 
-	/* Deselect all dataflash chips */
+	/* Deselect all Dataflash chips */
 	Dataflash_DeselectChip();
 }
 
-/** Reads blocks (OS blocks, not Dataflash pages) from the storage medium, the board dataflash IC(s), into
+/** Reads blocks (OS blocks, not Dataflash pages) from the storage medium, the board Dataflash IC(s), into
  *  the pre-selected data IN endpoint. This routine reads in Dataflash page sized blocks from the Dataflash
  *  and writes them in OS sized blocks to the endpoint.
  *
@@ -194,7 +194,7 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 	/* Select the correct starting Dataflash IC for the block requested */
 	Dataflash_SelectChipFromPage(CurrDFPage);
 
-	/* Send the dataflash main memory page read command */
+	/* Send the Dataflash main memory page read command */
 	Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
 	Dataflash_SendAddressBytes(CurrDFPage, CurrDFPageByte);
 	Dataflash_SendByte(0x00);
@@ -210,7 +210,7 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 	{
 		uint8_t BytesInBlockDiv16 = 0;
 		
-		/* Write an endpoint packet sized data block to the dataflash */
+		/* Write an endpoint packet sized data block to the Dataflash */
 		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
 		{
 			/* Check if the endpoint is currently full */
@@ -224,17 +224,17 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 				  return;
 			}
 			
-			/* Check if end of dataflash page reached */
+			/* Check if end of Dataflash page reached */
 			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
 			{
-				/* Reset the dataflash buffer counter, increment the page counter */
+				/* Reset the Dataflash buffer counter, increment the page counter */
 				CurrDFPageByteDiv16 = 0;
 				CurrDFPage++;
 
-				/* Select the next dataflash chip based on the new dataflash page index */
+				/* Select the next Dataflash chip based on the new Dataflash page index */
 				Dataflash_SelectChipFromPage(CurrDFPage);
 				
-				/* Send the dataflash main memory page read command */
+				/* Send the Dataflash main memory page read command */
 				Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
 				Dataflash_SendAddressBytes(CurrDFPage, 0);
 				Dataflash_SendByte(0x00);
@@ -243,7 +243,7 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 				Dataflash_SendByte(0x00);
 			}	
 
-			/* Read one 16-byte chunk of data from the dataflash */
+			/* Read one 16-byte chunk of data from the Dataflash */
 			Endpoint_Write_Byte(Dataflash_ReceiveByte());
 			Endpoint_Write_Byte(Dataflash_ReceiveByte());
 			Endpoint_Write_Byte(Dataflash_ReceiveByte());
@@ -261,7 +261,7 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 			Endpoint_Write_Byte(Dataflash_ReceiveByte());
 			Endpoint_Write_Byte(Dataflash_ReceiveByte());
 			
-			/* Increment the dataflash page 16 byte block counter */
+			/* Increment the Dataflash page 16 byte block counter */
 			CurrDFPageByteDiv16++;
 			
 			/* Increment the block 16 byte block counter */
@@ -280,14 +280,14 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 	if (!(Endpoint_IsReadWriteAllowed()))
 	  Endpoint_ClearIN();
 
-	/* Deselect all dataflash chips */
+	/* Deselect all Dataflash chips */
 	Dataflash_DeselectChip();
 }
 
-/** Writes blocks (OS blocks, not Dataflash pages) to the storage medium, the board dataflash IC(s), from
+/** Writes blocks (OS blocks, not Dataflash pages) to the storage medium, the board Dataflash IC(s), from
  *  the a given RAM buffer. This routine reads in OS sized blocks from the buffer and writes them to the
- *  dataflash in Dataflash page sized blocks. This can be linked to FAT libraries to write files to the
+ *  Dataflash in Dataflash page sized blocks. This can be linked to FAT libraries to write files to the
- *  dataflash.
+ *  Dataflash.
  *
  *  \param[in] BlockAddress  Data block starting address for the write sequence
  *  \param[in] TotalBlocks   Number of blocks of data to write
@@ -306,13 +306,13 @@ void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress,
 	Dataflash_SelectChipFromPage(CurrDFPage);
 
 #if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
-	/* Copy selected dataflash's current page contents to the dataflash buffer */
+	/* Copy selected dataflash's current page contents to the Dataflash buffer */
 	Dataflash_SendByte(DF_CMD_MAINMEMTOBUFF1);
 	Dataflash_SendAddressBytes(CurrDFPage, 0);
 	Dataflash_WaitWhileBusy();
 #endif
 
-	/* Send the dataflash buffer write command */
+	/* Send the Dataflash buffer write command */
 	Dataflash_SendByte(DF_CMD_BUFF1WRITE);
 	Dataflash_SendAddressBytes(0, CurrDFPageByte);
 	
@@ -320,33 +320,33 @@ void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress,
 	{
 		uint8_t BytesInBlockDiv16 = 0;
 		
-		/* Write an endpoint packet sized data block to the dataflash */
+		/* Write an endpoint packet sized data block to the Dataflash */
 		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
 		{
-			/* Check if end of dataflash page reached */
+			/* Check if end of Dataflash page reached */
 			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
 			{
-				/* Write the dataflash buffer contents back to the dataflash page */
+				/* Write the Dataflash buffer contents back to the Dataflash page */
 				Dataflash_WaitWhileBusy();
 				Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);
 				Dataflash_SendAddressBytes(CurrDFPage, 0);
 
-				/* Reset the dataflash buffer counter, increment the page counter */
+				/* Reset the Dataflash buffer counter, increment the page counter */
 				CurrDFPageByteDiv16 = 0;
 				CurrDFPage++;
 
-				/* Once all the dataflash ICs have had their first buffers filled, switch buffers to maintain throughput */
+				/* Once all the Dataflash ICs have had their first buffers filled, switch buffers to maintain throughput */
 				if (Dataflash_GetSelectedChip() == DATAFLASH_CHIP_MASK(DATAFLASH_TOTALCHIPS))
 				  UsingSecondBuffer = !(UsingSecondBuffer);
 
-				/* Select the next dataflash chip based on the new dataflash page index */
+				/* Select the next Dataflash chip based on the new Dataflash page index */
 				Dataflash_SelectChipFromPage(CurrDFPage);
 
 #if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
-				/* If less than one dataflash page remaining, copy over the existing page to preserve trailing data */
+				/* If less than one Dataflash page remaining, copy over the existing page to preserve trailing data */
 				if ((TotalBlocks * (VIRTUAL_MEMORY_BLOCK_SIZE >> 4)) < (DATAFLASH_PAGE_SIZE >> 4))
 				{
-					/* Copy selected dataflash's current page contents to the dataflash buffer */
+					/* Copy selected dataflash's current page contents to the Dataflash buffer */
 					Dataflash_WaitWhileBusy();
 					Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_MAINMEMTOBUFF2 : DF_CMD_MAINMEMTOBUFF1);
 					Dataflash_SendAddressBytes(CurrDFPage, 0);
@@ -354,17 +354,17 @@ void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress,
 				}
 #endif
 
-				/* Send the dataflash buffer write command */
+				/* Send the Dataflash buffer write command */
 				Dataflash_ToggleSelectedChipCS();
 				Dataflash_SendByte(DF_CMD_BUFF1WRITE);
 				Dataflash_SendAddressBytes(0, 0);
 			}
 			
-			/* Write one 16-byte chunk of data to the dataflash */
+			/* Write one 16-byte chunk of data to the Dataflash */
 			for (uint8_t ByteNum = 0; ByteNum < 16; ByteNum++)
 			  Dataflash_SendByte(*(BufferPtr++));
 			
-			/* Increment the dataflash page 16 byte block counter */
+			/* Increment the Dataflash page 16 byte block counter */
 			CurrDFPageByteDiv16++;
 
 			/* Increment the block 16 byte block counter */
@@ -375,20 +375,20 @@ void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress,
 		TotalBlocks--;
 	}
 
-	/* Write the dataflash buffer contents back to the dataflash page */
+	/* Write the Dataflash buffer contents back to the Dataflash page */
 	Dataflash_WaitWhileBusy();
 	Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);
 	Dataflash_SendAddressBytes(CurrDFPage, 0x00);
 	Dataflash_WaitWhileBusy();
 
-	/* Deselect all dataflash chips */
+	/* Deselect all Dataflash chips */
 	Dataflash_DeselectChip();
 }
 
-/** Reads blocks (OS blocks, not Dataflash pages) from the storage medium, the board dataflash IC(s), into
+/** Reads blocks (OS blocks, not Dataflash pages) from the storage medium, the board Dataflash IC(s), into
  *  the a preallocated RAM buffer. This routine reads in Dataflash page sized blocks from the Dataflash
  *  and writes them in OS sized blocks to the given buffer. This can be linked to FAT libraries to read
- *  the files stored on the dataflash.
+ *  the files stored on the Dataflash.
  *
  *  \param[in] BlockAddress  Data block starting address for the read sequence
  *  \param[in] TotalBlocks   Number of blocks of data to read
@@ -405,7 +405,7 @@ void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress,
 	/* Select the correct starting Dataflash IC for the block requested */
 	Dataflash_SelectChipFromPage(CurrDFPage);
 
-	/* Send the dataflash main memory page read command */
+	/* Send the Dataflash main memory page read command */
 	Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
 	Dataflash_SendAddressBytes(CurrDFPage, CurrDFPageByte);
 	Dataflash_SendByte(0x00);
@@ -417,20 +417,20 @@ void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress,
 	{
 		uint8_t BytesInBlockDiv16 = 0;
 		
-		/* Write an endpoint packet sized data block to the dataflash */
+		/* Write an endpoint packet sized data block to the Dataflash */
 		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
 		{
-			/* Check if end of dataflash page reached */
+			/* Check if end of Dataflash page reached */
 			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
 			{
-				/* Reset the dataflash buffer counter, increment the page counter */
+				/* Reset the Dataflash buffer counter, increment the page counter */
 				CurrDFPageByteDiv16 = 0;
 				CurrDFPage++;
 
-				/* Select the next dataflash chip based on the new dataflash page index */
+				/* Select the next Dataflash chip based on the new Dataflash page index */
 				Dataflash_SelectChipFromPage(CurrDFPage);
 				
-				/* Send the dataflash main memory page read command */
+				/* Send the Dataflash main memory page read command */
 				Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
 				Dataflash_SendAddressBytes(CurrDFPage, 0);
 				Dataflash_SendByte(0x00);
@@ -439,11 +439,11 @@ void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress,
 				Dataflash_SendByte(0x00);
 			}	
 
-			/* Read one 16-byte chunk of data from the dataflash */
+			/* Read one 16-byte chunk of data from the Dataflash */
 			for (uint8_t ByteNum = 0; ByteNum < 16; ByteNum++)
 			  *(BufferPtr++) = Dataflash_ReceiveByte();
 			
-			/* Increment the dataflash page 16 byte block counter */
+			/* Increment the Dataflash page 16 byte block counter */
 			CurrDFPageByteDiv16++;
 			
 			/* Increment the block 16 byte block counter */
@@ -454,14 +454,14 @@ void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress,
 		TotalBlocks--;
 	}
 
-	/* Deselect all dataflash chips */
+	/* Deselect all Dataflash chips */
 	Dataflash_DeselectChip();
 }
 
-/** Disables the dataflash memory write protection bits on the board Dataflash ICs, if enabled. */
+/** Disables the Dataflash memory write protection bits on the board Dataflash ICs, if enabled. */
 void DataflashManager_ResetDataflashProtections(void)
 {
-	/* Select first dataflash chip, send the read status register command */
+	/* Select first Dataflash chip, send the read status register command */
 	Dataflash_SelectChip(DATAFLASH_CHIP1);
 	Dataflash_SendByte(DF_CMD_GETSTATUS);
 	
@@ -477,7 +477,7 @@ void DataflashManager_ResetDataflashProtections(void)
 		Dataflash_SendByte(DF_CMD_SECTORPROTECTIONOFF[3]);
 	}
 	
-	/* Select second dataflash chip (if present on selected board), send read status register command */
+	/* Select second Dataflash chip (if present on selected board), send read status register command */
 	#if (DATAFLASH_TOTALCHIPS == 2)
 	Dataflash_SelectChip(DATAFLASH_CHIP2);
 	Dataflash_SendByte(DF_CMD_GETSTATUS);
@@ -495,7 +495,7 @@ void DataflashManager_ResetDataflashProtections(void)
 	}
 	#endif
 	
-	/* Deselect current dataflash chip */
+	/* Deselect current Dataflash chip */
 	Dataflash_DeselectChip();
 }
 

Projects/TempDataLogger/Lib/FATFs/00readme.txt

@@ -41,14 +41,14 @@ REVISION HISTORY
 
   Jun 01, 2006  R0.02  Added FAT12.
                        Removed unbuffered mode.
-                       Fixed a problem on small (<32M) patition.
+                       Fixed a problem on small (<32M) partition.
 
   Jun 10, 2006  R0.02a Added a configuration option _FS_MINIMUM.
 
   Sep 22, 2006  R0.03  Added f_rename.
                        Changed option _FS_MINIMUM to _FS_MINIMIZE.
 
-  Dec 11, 2006  R0.03a Improved cluster scan algolithm to write files fast.
+  Dec 11, 2006  R0.03a Improved cluster scan algorithm to write files fast.
                        Fixed f_mkdir creates incorrect directory on FAT32.
 
   Feb 04, 2007  R0.04  Supported multiple drive system. (FatFs)
@@ -56,7 +56,7 @@ REVISION HISTORY
                        Added f_mkfs. (FatFs)
                        Added _USE_FAT32 option. (Tiny-FatFs)
 
-  Apr 01, 2007  R0.04a Supported multiple partitions on a plysical drive. (FatFs)
+  Apr 01, 2007  R0.04a Supported multiple partitions on a physical drive. (FatFs)
                        Fixed an endian sensitive code in f_mkfs. (FatFs)
                        Added a capability of extending the file size to f_lseek.
                        Added minimization level 3.

Projects/TempDataLogger/Lib/FATFs/diskio.c

@@ -8,10 +8,10 @@
 #include "diskio.h"
 
 /*-----------------------------------------------------------------------*/
-/* Inidialize a Drive                                                    */
+/* Initialize a Drive                                                    */
 
 DSTATUS disk_initialize (
-	BYTE drv				/* Physical drive nmuber (0..) */
+	BYTE drv				/* Physical drive number (0..) */
 )
 {
 	return FR_OK;
@@ -23,7 +23,7 @@ DSTATUS disk_initialize (
 /* Return Disk Status                                                    */
 
 DSTATUS disk_status (
-	BYTE drv		/* Physical drive nmuber (0..) */
+	BYTE drv		/* Physical drive number (0..) */
 )
 {
 	return FR_OK;
@@ -35,7 +35,7 @@ DSTATUS disk_status (
 /* Read Sector(s)                                                        */
 
 DRESULT disk_read (
-	BYTE drv,		/* Physical drive nmuber (0..) */
+	BYTE drv,		/* Physical drive number (0..) */
 	BYTE *buff,		/* Data buffer to store read data */
 	DWORD sector,	/* Sector address (LBA) */
 	BYTE count		/* Number of sectors to read (1..255) */
@@ -52,7 +52,7 @@ DRESULT disk_read (
 
 #if _READONLY == 0
 DRESULT disk_write (
-	BYTE drv,			/* Physical drive nmuber (0..) */
+	BYTE drv,			/* Physical drive number (0..) */
 	const BYTE *buff,	/* Data to be written */
 	DWORD sector,		/* Sector address (LBA) */
 	BYTE count			/* Number of sectors to write (1..255) */
@@ -69,7 +69,7 @@ DRESULT disk_write (
 /* Miscellaneous Functions                                               */
 
 DRESULT disk_ioctl (
-	BYTE drv,		/* Physical drive nmuber (0..) */
+	BYTE drv,		/* Physical drive number (0..) */
 	BYTE ctrl,		/* Control code */
 	void *buff		/* Buffer to send/receive control data */
 )

Projects/TempDataLogger/Lib/FATFs/diskio.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------------------------------------
-/  Low level disk interface modlue include file  R0.07   (C)ChaN, 2010
+/  Low level disk interface module include file  R0.07   (C)ChaN, 2010
 /-----------------------------------------------------------------------*/
 
 #ifndef _DISKIO

Projects/TempDataLogger/Lib/FATFs/ff.c

@@ -1593,7 +1593,7 @@ FRESULT follow_path (	/* FR_OK(0): successful, !=0: error code */
 			res = dir_find(dj);				/* Find it */
 			ns = *(dj->fn+NS);
 			if (res != FR_OK) {				/* Failed to find the object */
-				if (res != FR_NO_FILE) break;	/* Abort if any hard error occured */
+				if (res != FR_NO_FILE) break;	/* Abort if any hard error occurred */
 				/* Object not found */
 				if (_FS_RPATH && (ns & NS_DOT)) {	/* If dot entry is not exit */
 					dj->sclust = 0; dj->dir = 0;	/* It is the root dir */
@@ -1710,7 +1710,7 @@ FRESULT chk_mounted (	/* FR_OK(0): successful, !=0: any error occurred */
 	if (chk_wp && (stat & STA_PROTECT))	/* Check disk write protection if needed */
 		return FR_WRITE_PROTECTED;
 #endif
-	/* Search FAT partition on the drive (Supports only generic partitionings, FDISK and SFD) */
+	/* Search FAT partition on the drive (Supports only generic partitions, FDISK and SFD) */
 	fmt = check_fs(fs, bsect = 0);		/* Check sector 0 if it is a VBR */
 	if (fmt == 1) {						/* Not an FAT-VBR, the disk may be partitioned */
 		/* Check the partition listed in top of the partition table */
@@ -2569,7 +2569,7 @@ FRESULT f_opendir (
 
 
 /*-----------------------------------------------------------------------*/
-/* Read Directory Entry in Sequense                                      */
+/* Read Directory Entry in Sequence                                      */
 /*-----------------------------------------------------------------------*/
 
 FRESULT f_readdir (
@@ -2943,7 +2943,7 @@ FRESULT f_chmod (
 
 
 /*-----------------------------------------------------------------------*/
-/* Change Timestamp                                                      */
+/* Change Time-stamp                                                      */
 /*-----------------------------------------------------------------------*/
 
 FRESULT f_utime (
@@ -3361,18 +3361,18 @@ TCHAR* f_gets (
 #if _LFN_UNICODE					/* Read a character in UTF-8 encoding */
 		if (c >= 0x80) {
 			if (c < 0xC0) continue;	/* Skip stray trailer */
-			if (c < 0xE0) {			/* Two-byte sequense */
+			if (c < 0xE0) {			/* Two-byte sequence */
 				f_read(fil, s, 1, &rc);
 				if (rc != 1) break;
 				c = ((c & 0x1F) << 6) | (s[0] & 0x3F);
 				if (c < 0x80) c = '?';
 			} else {
-				if (c < 0xF0) {		/* Three-byte sequense */
+				if (c < 0xF0) {		/* Three-byte sequence */
 					f_read(fil, s, 2, &rc);
 					if (rc != 2) break;
 					c = (c << 12) | ((s[0] & 0x3F) << 6) | (s[1] & 0x3F);
 					if (c < 0x800) c = '?';
-				} else {			/* Reject four-byte sequense */
+				} else {			/* Reject four-byte sequence */
 					c = '?';
 				}
 			}
@@ -3510,7 +3510,7 @@ int f_printf (
 		case 'D' :					/* Signed decimal */
 		case 'U' :					/* Unsigned decimal */
 			r = 10; break;
-		case 'X' :					/* Hexdecimal */
+		case 'X' :					/* Hexadecimal */
 			r = 16; break;
 		default:					/* Unknown */
 			cc = f_putc(c, fil); continue;

Projects/TempDataLogger/Lib/FATFs/ffconf.h

@@ -113,7 +113,7 @@
 #define _FS_RPATH	0		/* 0:Disable or 1:Enable */
 /* When _FS_RPATH is set to 1, relative path feature is enabled and f_chdir,
 /  f_chdrive function are available.
-/  Note that output of the f_readdir fnction is affected by this option. */
+/  Note that output of the f_readdir function is affected by this option. */
 
 
 
@@ -129,13 +129,13 @@
 /* Maximum sector size to be handled.
 /  Always set 512 for memory card and hard disk but a larger value may be
 /  required for floppy disk (512/1024) and optical disk (512/2048).
-/  When _MAX_SS is larger than 512, GET_SECTOR_SIZE command must be implememted
+/  When _MAX_SS is larger than 512, GET_SECTOR_SIZE command must be implemented
 /  to the disk_ioctl function. */
 
 
-#define	_MULTI_PARTITION	0	/* 0:Single parition or 1:Multiple partition */
+#define	_MULTI_PARTITION	0	/* 0:Single partition or 1:Multiple partition */
 /* When _MULTI_PARTITION is set to 0, each volume is bound to the same physical
-/ drive number and can mount only first primaly partition. When it is set to 1,
+/ drive number and can mount only first primary partition. When it is set to 1,
 / each volume is tied to the partitions listed in Drives[]. */
 
 
@@ -161,7 +161,7 @@
 #define _FS_TIMEOUT		1000	/* Timeout period in unit of time ticks */
 #define	_SYNC_t			HANDLE	/* O/S dependent type of sync object. e.g. HANDLE, OS_EVENT*, ID and etc.. */
 /* Include a header file here to define O/S system calls */
-/* #include <windows.h>, <ucos_ii.h.h>, <semphr.h> or ohters. */
+/* #include <windows.h>, <ucos_ii.h.h>, <semphr.h> or others. */
 
 /* The _FS_REENTRANT option switches the reentrancy of the FatFs module.
 /
@@ -172,7 +172,7 @@
 
 
 #define	_FS_SHARE	0	/* 0:Disable or >=1:Enable */
-/* To enable file shareing feature, set _FS_SHARE to >= 1 and also user
+/* To enable file sharing feature, set _FS_SHARE to >= 1 and also user
    provided memory handlers, ff_memalloc and ff_memfree function must be
    added to the project. The value defines number of files can be opened
    per volume. */

Projects/TempDataLogger/Lib/SCSI.c

@@ -241,7 +241,7 @@ static void SCSI_Command_Send_Diagnostic(USB_ClassInfo_MS_Device_t* const MSInte
 }
 
 /** Command processing for an issued SCSI READ (10) or WRITE (10) command. This command reads in the block start address
- *  and total number of blocks to process, then calls the appropriate low-level dataflash routine to handle the actual
+ *  and total number of blocks to process, then calls the appropriate low-level Dataflash routine to handle the actual
  *  reading and writing of the data.
  *
  *  \param[in] MSInterfaceInfo  Pointer to the Mass Storage class interface structure that the command is associated with

Projects/TempDataLogger/TempDataLogger.c

@@ -89,7 +89,7 @@ uint8_t LoggingInterval500MS_SRAM;
 /** Total number of 500ms logging ticks elapsed since the last log value was recorded */
 uint16_t CurrentLoggingTicks;
 
-/** FAT Fs structure to hold the internal state of the FAT driver for the dataflash contents. */
+/** FAT Fs structure to hold the internal state of the FAT driver for the Dataflash contents. */
 FATFS DiskFATState;
 
 /** FAT Fs structure to hold a FAT file handle for the log data write destination. */
@@ -146,7 +146,7 @@ int main(void)
 	if (LoggingInterval500MS_SRAM == 0xFF)
 	  LoggingInterval500MS_SRAM = DEFAULT_LOG_INTERVAL;
 
-	/* Mount and open the log file on the dataflash FAT partition */
+	/* Mount and open the log file on the Dataflash FAT partition */
 	OpenLogFile();
 
 	LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
@@ -230,7 +230,7 @@ void EVENT_USB_Device_Disconnect(void)
 {
 	LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
 	
-	/* Mount and open the log file on the dataflash FAT partition */
+	/* Mount and open the log file on the Dataflash FAT partition */
 	OpenLogFile();
 }
 

Projects/TempDataLogger/TemperatureDataLogger.txt

@@ -67,7 +67,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
+ *  The following defines can be found in this demo, which can control the demo behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Projects/USBtoSerial/USBtoSerial.txt

@@ -65,7 +65,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this project, which can control the project behaviour when defined, or changed in value.
+ *  The following defines can be found in this project, which can control the project behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

Projects/Webserver/Lib/DataflashManager.c

@@ -30,7 +30,7 @@
 
 /** \file
  *
- *  Functions to manage the physical dataflash media, including reading and writing of
+ *  Functions to manage the physical Dataflash media, including reading and writing of
  *  blocks of data. These functions are called by the SCSI layer when data must be stored
  *  or retrieved to/from the physical storage media. If a different media is used (such
  *  as a SD card or EEPROM), functions similar to these will need to be generated.
@@ -39,9 +39,9 @@
 #define  INCLUDE_FROM_DATAFLASHMANAGER_C
 #include "DataflashManager.h"
 
-/** Writes blocks (OS blocks, not Dataflash pages) to the storage medium, the board dataflash IC(s), from
+/** Writes blocks (OS blocks, not Dataflash pages) to the storage medium, the board Dataflash IC(s), from
  *  the pre-selected data OUT endpoint. This routine reads in OS sized blocks from the endpoint and writes
- *  them to the dataflash in Dataflash page sized blocks.
+ *  them to the Dataflash in Dataflash page sized blocks.
  *
  *  \param[in] MSInterfaceInfo  Pointer to a structure containing a Mass Storage Class configuration and state
  *  \param[in] BlockAddress  Data block starting address for the write sequence
@@ -60,13 +60,13 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 	Dataflash_SelectChipFromPage(CurrDFPage);
 
 #if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
-	/* Copy selected dataflash's current page contents to the dataflash buffer */
+	/* Copy selected dataflash's current page contents to the Dataflash buffer */
 	Dataflash_SendByte(DF_CMD_MAINMEMTOBUFF1);
 	Dataflash_SendAddressBytes(CurrDFPage, 0);
 	Dataflash_WaitWhileBusy();
 #endif
 
-	/* Send the dataflash buffer write command */
+	/* Send the Dataflash buffer write command */
 	Dataflash_SendByte(DF_CMD_BUFF1WRITE);
 	Dataflash_SendAddressBytes(0, CurrDFPageByte);
 
@@ -78,7 +78,7 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 	{
 		uint8_t BytesInBlockDiv16 = 0;
 		
-		/* Write an endpoint packet sized data block to the dataflash */
+		/* Write an endpoint packet sized data block to the Dataflash */
 		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
 		{
 			/* Check if the endpoint is currently empty */
@@ -92,30 +92,30 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 				  return;
 			}
 
-			/* Check if end of dataflash page reached */
+			/* Check if end of Dataflash page reached */
 			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
 			{
-				/* Write the dataflash buffer contents back to the dataflash page */
+				/* Write the Dataflash buffer contents back to the Dataflash page */
 				Dataflash_WaitWhileBusy();
 				Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);
 				Dataflash_SendAddressBytes(CurrDFPage, 0);
 
-				/* Reset the dataflash buffer counter, increment the page counter */
+				/* Reset the Dataflash buffer counter, increment the page counter */
 				CurrDFPageByteDiv16 = 0;
 				CurrDFPage++;
 
-				/* Once all the dataflash ICs have had their first buffers filled, switch buffers to maintain throughput */
+				/* Once all the Dataflash ICs have had their first buffers filled, switch buffers to maintain throughput */
 				if (Dataflash_GetSelectedChip() == DATAFLASH_CHIP_MASK(DATAFLASH_TOTALCHIPS))
 				  UsingSecondBuffer = !(UsingSecondBuffer);
 
-				/* Select the next dataflash chip based on the new dataflash page index */
+				/* Select the next Dataflash chip based on the new Dataflash page index */
 				Dataflash_SelectChipFromPage(CurrDFPage);
 
 #if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
-				/* If less than one dataflash page remaining, copy over the existing page to preserve trailing data */
+				/* If less than one Dataflash page remaining, copy over the existing page to preserve trailing data */
 				if ((TotalBlocks * (VIRTUAL_MEMORY_BLOCK_SIZE >> 4)) < (DATAFLASH_PAGE_SIZE >> 4))
 				{
-					/* Copy selected dataflash's current page contents to the dataflash buffer */
+					/* Copy selected dataflash's current page contents to the Dataflash buffer */
 					Dataflash_WaitWhileBusy();
 					Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_MAINMEMTOBUFF2 : DF_CMD_MAINMEMTOBUFF1);
 					Dataflash_SendAddressBytes(CurrDFPage, 0);
@@ -123,12 +123,12 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 				}
 #endif
 
-				/* Send the dataflash buffer write command */
+				/* Send the Dataflash buffer write command */
 				Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2WRITE : DF_CMD_BUFF1WRITE);
 				Dataflash_SendAddressBytes(0, 0);				
 			}
 
-			/* Write one 16-byte chunk of data to the dataflash */
+			/* Write one 16-byte chunk of data to the Dataflash */
 			Dataflash_SendByte(Endpoint_Read_Byte());
 			Dataflash_SendByte(Endpoint_Read_Byte());
 			Dataflash_SendByte(Endpoint_Read_Byte());
@@ -146,7 +146,7 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 			Dataflash_SendByte(Endpoint_Read_Byte());
 			Dataflash_SendByte(Endpoint_Read_Byte());
 			
-			/* Increment the dataflash page 16 byte block counter */
+			/* Increment the Dataflash page 16 byte block counter */
 			CurrDFPageByteDiv16++;
 
 			/* Increment the block 16 byte block counter */
@@ -161,7 +161,7 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 		TotalBlocks--;
 	}
 
-	/* Write the dataflash buffer contents back to the dataflash page */
+	/* Write the Dataflash buffer contents back to the Dataflash page */
 	Dataflash_WaitWhileBusy();
 	Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);
 	Dataflash_SendAddressBytes(CurrDFPage, 0x00);
@@ -171,11 +171,11 @@ void DataflashManager_WriteBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceIn
 	if (!(Endpoint_IsReadWriteAllowed()))
 	  Endpoint_ClearOUT();
 
-	/* Deselect all dataflash chips */
+	/* Deselect all Dataflash chips */
 	Dataflash_DeselectChip();
 }
 
-/** Reads blocks (OS blocks, not Dataflash pages) from the storage medium, the board dataflash IC(s), into
+/** Reads blocks (OS blocks, not Dataflash pages) from the storage medium, the board Dataflash IC(s), into
  *  the pre-selected data IN endpoint. This routine reads in Dataflash page sized blocks from the Dataflash
  *  and writes them in OS sized blocks to the endpoint.
  *
@@ -194,7 +194,7 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 	/* Select the correct starting Dataflash IC for the block requested */
 	Dataflash_SelectChipFromPage(CurrDFPage);
 
-	/* Send the dataflash main memory page read command */
+	/* Send the Dataflash main memory page read command */
 	Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
 	Dataflash_SendAddressBytes(CurrDFPage, CurrDFPageByte);
 	Dataflash_SendByte(0x00);
@@ -210,7 +210,7 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 	{
 		uint8_t BytesInBlockDiv16 = 0;
 		
-		/* Write an endpoint packet sized data block to the dataflash */
+		/* Write an endpoint packet sized data block to the Dataflash */
 		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
 		{
 			/* Check if the endpoint is currently full */
@@ -224,17 +224,17 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 				  return;
 			}
 			
-			/* Check if end of dataflash page reached */
+			/* Check if end of Dataflash page reached */
 			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
 			{
-				/* Reset the dataflash buffer counter, increment the page counter */
+				/* Reset the Dataflash buffer counter, increment the page counter */
 				CurrDFPageByteDiv16 = 0;
 				CurrDFPage++;
 
-				/* Select the next dataflash chip based on the new dataflash page index */
+				/* Select the next Dataflash chip based on the new Dataflash page index */
 				Dataflash_SelectChipFromPage(CurrDFPage);
 				
-				/* Send the dataflash main memory page read command */
+				/* Send the Dataflash main memory page read command */
 				Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
 				Dataflash_SendAddressBytes(CurrDFPage, 0);
 				Dataflash_SendByte(0x00);
@@ -243,7 +243,7 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 				Dataflash_SendByte(0x00);
 			}	
 
-			/* Read one 16-byte chunk of data from the dataflash */
+			/* Read one 16-byte chunk of data from the Dataflash */
 			Endpoint_Write_Byte(Dataflash_ReceiveByte());
 			Endpoint_Write_Byte(Dataflash_ReceiveByte());
 			Endpoint_Write_Byte(Dataflash_ReceiveByte());
@@ -261,7 +261,7 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 			Endpoint_Write_Byte(Dataflash_ReceiveByte());
 			Endpoint_Write_Byte(Dataflash_ReceiveByte());
 			
-			/* Increment the dataflash page 16 byte block counter */
+			/* Increment the Dataflash page 16 byte block counter */
 			CurrDFPageByteDiv16++;
 			
 			/* Increment the block 16 byte block counter */
@@ -280,14 +280,14 @@ void DataflashManager_ReadBlocks(USB_ClassInfo_MS_Device_t* const MSInterfaceInf
 	if (!(Endpoint_IsReadWriteAllowed()))
 	  Endpoint_ClearIN();
 
-	/* Deselect all dataflash chips */
+	/* Deselect all Dataflash chips */
 	Dataflash_DeselectChip();
 }
 
-/** Writes blocks (OS blocks, not Dataflash pages) to the storage medium, the board dataflash IC(s), from
+/** Writes blocks (OS blocks, not Dataflash pages) to the storage medium, the board Dataflash IC(s), from
  *  the a given RAM buffer. This routine reads in OS sized blocks from the buffer and writes them to the
- *  dataflash in Dataflash page sized blocks. This can be linked to FAT libraries to write files to the
+ *  Dataflash in Dataflash page sized blocks. This can be linked to FAT libraries to write files to the
- *  dataflash.
+ *  Dataflash.
  *
  *  \param[in] BlockAddress  Data block starting address for the write sequence
  *  \param[in] TotalBlocks   Number of blocks of data to write
@@ -306,13 +306,13 @@ void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress,
 	Dataflash_SelectChipFromPage(CurrDFPage);
 
 #if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
-	/* Copy selected dataflash's current page contents to the dataflash buffer */
+	/* Copy selected dataflash's current page contents to the Dataflash buffer */
 	Dataflash_SendByte(DF_CMD_MAINMEMTOBUFF1);
 	Dataflash_SendAddressBytes(CurrDFPage, 0);
 	Dataflash_WaitWhileBusy();
 #endif
 
-	/* Send the dataflash buffer write command */
+	/* Send the Dataflash buffer write command */
 	Dataflash_SendByte(DF_CMD_BUFF1WRITE);
 	Dataflash_SendAddressBytes(0, CurrDFPageByte);
 	
@@ -320,33 +320,33 @@ void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress,
 	{
 		uint8_t BytesInBlockDiv16 = 0;
 		
-		/* Write an endpoint packet sized data block to the dataflash */
+		/* Write an endpoint packet sized data block to the Dataflash */
 		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
 		{
-			/* Check if end of dataflash page reached */
+			/* Check if end of Dataflash page reached */
 			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
 			{
-				/* Write the dataflash buffer contents back to the dataflash page */
+				/* Write the Dataflash buffer contents back to the Dataflash page */
 				Dataflash_WaitWhileBusy();
 				Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);
 				Dataflash_SendAddressBytes(CurrDFPage, 0);
 
-				/* Reset the dataflash buffer counter, increment the page counter */
+				/* Reset the Dataflash buffer counter, increment the page counter */
 				CurrDFPageByteDiv16 = 0;
 				CurrDFPage++;
 
-				/* Once all the dataflash ICs have had their first buffers filled, switch buffers to maintain throughput */
+				/* Once all the Dataflash ICs have had their first buffers filled, switch buffers to maintain throughput */
 				if (Dataflash_GetSelectedChip() == DATAFLASH_CHIP_MASK(DATAFLASH_TOTALCHIPS))
 				  UsingSecondBuffer = !(UsingSecondBuffer);
 
-				/* Select the next dataflash chip based on the new dataflash page index */
+				/* Select the next Dataflash chip based on the new Dataflash page index */
 				Dataflash_SelectChipFromPage(CurrDFPage);
 
 #if (DATAFLASH_PAGE_SIZE > VIRTUAL_MEMORY_BLOCK_SIZE)
-				/* If less than one dataflash page remaining, copy over the existing page to preserve trailing data */
+				/* If less than one Dataflash page remaining, copy over the existing page to preserve trailing data */
 				if ((TotalBlocks * (VIRTUAL_MEMORY_BLOCK_SIZE >> 4)) < (DATAFLASH_PAGE_SIZE >> 4))
 				{
-					/* Copy selected dataflash's current page contents to the dataflash buffer */
+					/* Copy selected dataflash's current page contents to the Dataflash buffer */
 					Dataflash_WaitWhileBusy();
 					Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_MAINMEMTOBUFF2 : DF_CMD_MAINMEMTOBUFF1);
 					Dataflash_SendAddressBytes(CurrDFPage, 0);
@@ -354,17 +354,17 @@ void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress,
 				}
 #endif
 
-				/* Send the dataflash buffer write command */
+				/* Send the Dataflash buffer write command */
 				Dataflash_ToggleSelectedChipCS();
 				Dataflash_SendByte(DF_CMD_BUFF1WRITE);
 				Dataflash_SendAddressBytes(0, 0);
 			}
 			
-			/* Write one 16-byte chunk of data to the dataflash */
+			/* Write one 16-byte chunk of data to the Dataflash */
 			for (uint8_t ByteNum = 0; ByteNum < 16; ByteNum++)
 			  Dataflash_SendByte(*(BufferPtr++));
 			
-			/* Increment the dataflash page 16 byte block counter */
+			/* Increment the Dataflash page 16 byte block counter */
 			CurrDFPageByteDiv16++;
 
 			/* Increment the block 16 byte block counter */
@@ -375,20 +375,20 @@ void DataflashManager_WriteBlocks_RAM(const uint32_t BlockAddress,
 		TotalBlocks--;
 	}
 
-	/* Write the dataflash buffer contents back to the dataflash page */
+	/* Write the Dataflash buffer contents back to the Dataflash page */
 	Dataflash_WaitWhileBusy();
 	Dataflash_SendByte(UsingSecondBuffer ? DF_CMD_BUFF2TOMAINMEMWITHERASE : DF_CMD_BUFF1TOMAINMEMWITHERASE);
 	Dataflash_SendAddressBytes(CurrDFPage, 0x00);
 	Dataflash_WaitWhileBusy();
 
-	/* Deselect all dataflash chips */
+	/* Deselect all Dataflash chips */
 	Dataflash_DeselectChip();
 }
 
-/** Reads blocks (OS blocks, not Dataflash pages) from the storage medium, the board dataflash IC(s), into
+/** Reads blocks (OS blocks, not Dataflash pages) from the storage medium, the board Dataflash IC(s), into
  *  the a preallocated RAM buffer. This routine reads in Dataflash page sized blocks from the Dataflash
  *  and writes them in OS sized blocks to the given buffer. This can be linked to FAT libraries to read
- *  the files stored on the dataflash.
+ *  the files stored on the Dataflash.
  *
  *  \param[in] BlockAddress  Data block starting address for the read sequence
  *  \param[in] TotalBlocks   Number of blocks of data to read
@@ -405,7 +405,7 @@ void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress,
 	/* Select the correct starting Dataflash IC for the block requested */
 	Dataflash_SelectChipFromPage(CurrDFPage);
 
-	/* Send the dataflash main memory page read command */
+	/* Send the Dataflash main memory page read command */
 	Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
 	Dataflash_SendAddressBytes(CurrDFPage, CurrDFPageByte);
 	Dataflash_SendByte(0x00);
@@ -417,20 +417,20 @@ void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress,
 	{
 		uint8_t BytesInBlockDiv16 = 0;
 		
-		/* Write an endpoint packet sized data block to the dataflash */
+		/* Write an endpoint packet sized data block to the Dataflash */
 		while (BytesInBlockDiv16 < (VIRTUAL_MEMORY_BLOCK_SIZE >> 4))
 		{
-			/* Check if end of dataflash page reached */
+			/* Check if end of Dataflash page reached */
 			if (CurrDFPageByteDiv16 == (DATAFLASH_PAGE_SIZE >> 4))
 			{
-				/* Reset the dataflash buffer counter, increment the page counter */
+				/* Reset the Dataflash buffer counter, increment the page counter */
 				CurrDFPageByteDiv16 = 0;
 				CurrDFPage++;
 
-				/* Select the next dataflash chip based on the new dataflash page index */
+				/* Select the next Dataflash chip based on the new Dataflash page index */
 				Dataflash_SelectChipFromPage(CurrDFPage);
 				
-				/* Send the dataflash main memory page read command */
+				/* Send the Dataflash main memory page read command */
 				Dataflash_SendByte(DF_CMD_MAINMEMPAGEREAD);
 				Dataflash_SendAddressBytes(CurrDFPage, 0);
 				Dataflash_SendByte(0x00);
@@ -439,11 +439,11 @@ void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress,
 				Dataflash_SendByte(0x00);
 			}	
 
-			/* Read one 16-byte chunk of data from the dataflash */
+			/* Read one 16-byte chunk of data from the Dataflash */
 			for (uint8_t ByteNum = 0; ByteNum < 16; ByteNum++)
 			  *(BufferPtr++) = Dataflash_ReceiveByte();
 			
-			/* Increment the dataflash page 16 byte block counter */
+			/* Increment the Dataflash page 16 byte block counter */
 			CurrDFPageByteDiv16++;
 			
 			/* Increment the block 16 byte block counter */
@@ -454,14 +454,14 @@ void DataflashManager_ReadBlocks_RAM(const uint32_t BlockAddress,
 		TotalBlocks--;
 	}
 
-	/* Deselect all dataflash chips */
+	/* Deselect all Dataflash chips */
 	Dataflash_DeselectChip();
 }
 
-/** Disables the dataflash memory write protection bits on the board Dataflash ICs, if enabled. */
+/** Disables the Dataflash memory write protection bits on the board Dataflash ICs, if enabled. */
 void DataflashManager_ResetDataflashProtections(void)
 {
-	/* Select first dataflash chip, send the read status register command */
+	/* Select first Dataflash chip, send the read status register command */
 	Dataflash_SelectChip(DATAFLASH_CHIP1);
 	Dataflash_SendByte(DF_CMD_GETSTATUS);
 	
@@ -477,7 +477,7 @@ void DataflashManager_ResetDataflashProtections(void)
 		Dataflash_SendByte(DF_CMD_SECTORPROTECTIONOFF[3]);
 	}
 	
-	/* Select second dataflash chip (if present on selected board), send read status register command */
+	/* Select second Dataflash chip (if present on selected board), send read status register command */
 	#if (DATAFLASH_TOTALCHIPS == 2)
 	Dataflash_SelectChip(DATAFLASH_CHIP2);
 	Dataflash_SendByte(DF_CMD_GETSTATUS);
@@ -495,7 +495,7 @@ void DataflashManager_ResetDataflashProtections(void)
 	}
 	#endif
 	
-	/* Deselect current dataflash chip */
+	/* Deselect current Dataflash chip */
 	Dataflash_DeselectChip();
 }
 

Projects/Webserver/Lib/FATFs/00readme.txt

@@ -41,14 +41,14 @@ REVISION HISTORY
 
   Jun 01, 2006  R0.02  Added FAT12.
                        Removed unbuffered mode.
-                       Fixed a problem on small (<32M) patition.
+                       Fixed a problem on small (<32M) partition.
 
   Jun 10, 2006  R0.02a Added a configuration option _FS_MINIMUM.
 
   Sep 22, 2006  R0.03  Added f_rename.
                        Changed option _FS_MINIMUM to _FS_MINIMIZE.
 
-  Dec 11, 2006  R0.03a Improved cluster scan algolithm to write files fast.
+  Dec 11, 2006  R0.03a Improved cluster scan algorithm to write files fast.
                        Fixed f_mkdir creates incorrect directory on FAT32.
 
   Feb 04, 2007  R0.04  Supported multiple drive system. (FatFs)
@@ -56,7 +56,7 @@ REVISION HISTORY
                        Added f_mkfs. (FatFs)
                        Added _USE_FAT32 option. (Tiny-FatFs)
 
-  Apr 01, 2007  R0.04a Supported multiple partitions on a plysical drive. (FatFs)
+  Apr 01, 2007  R0.04a Supported multiple partitions on a physical drive. (FatFs)
                        Fixed an endian sensitive code in f_mkfs. (FatFs)
                        Added a capability of extending the file size to f_lseek.
                        Added minimization level 3.

Projects/Webserver/Lib/FATFs/diskio.c

@@ -8,10 +8,10 @@
 #include "diskio.h"
 
 /*-----------------------------------------------------------------------*/
-/* Inidialize a Drive                                                    */
+/* Initialize a Drive                                                    */
 
 DSTATUS disk_initialize (
-	BYTE drv				/* Physical drive nmuber (0..) */
+	BYTE drv				/* Physical drive number (0..) */
 )
 {
 	return FR_OK;
@@ -23,7 +23,7 @@ DSTATUS disk_initialize (
 /* Return Disk Status                                                    */
 
 DSTATUS disk_status (
-	BYTE drv		/* Physical drive nmuber (0..) */
+	BYTE drv		/* Physical drive number (0..) */
 )
 {
 	return FR_OK;
@@ -35,7 +35,7 @@ DSTATUS disk_status (
 /* Read Sector(s)                                                        */
 
 DRESULT disk_read (
-	BYTE drv,		/* Physical drive nmuber (0..) */
+	BYTE drv,		/* Physical drive number (0..) */
 	BYTE *buff,		/* Data buffer to store read data */
 	DWORD sector,	/* Sector address (LBA) */
 	BYTE count		/* Number of sectors to read (1..255) */
@@ -52,7 +52,7 @@ DRESULT disk_read (
 
 #if _READONLY == 0
 DRESULT disk_write (
-	BYTE drv,			/* Physical drive nmuber (0..) */
+	BYTE drv,			/* Physical drive number (0..) */
 	const BYTE *buff,	/* Data to be written */
 	DWORD sector,		/* Sector address (LBA) */
 	BYTE count			/* Number of sectors to write (1..255) */

Projects/Webserver/Lib/FATFs/diskio.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------------------------------------
-/  Low level disk interface modlue include file  R0.07   (C)ChaN, 2010
+/  Low level disk interface module include file  R0.07   (C)ChaN, 2010
 /-----------------------------------------------------------------------*/
 
 #ifndef _DISKIO

Projects/Webserver/Lib/FATFs/ff.c

@@ -304,7 +304,7 @@ void unlock_fs (
 
 
 /*-----------------------------------------------------------------------*/
-/* File shareing control functions                                       */
+/* File sharing control functions                                       */
 /*-----------------------------------------------------------------------*/
 #if _FS_SHARE
 
@@ -495,7 +495,7 @@ DWORD get_fat (	/* 0xFFFFFFFF:Disk error, 1:Internal error, Else:Cluster status
 	BYTE *p;
 
 
-	if (clst < 2 || clst >= fs->n_fatent)	/* Chack range */
+	if (clst < 2 || clst >= fs->n_fatent)	/* Check range */
 		return 1;
 
 	switch (fs->fs_type) {
@@ -1593,7 +1593,7 @@ FRESULT follow_path (	/* FR_OK(0): successful, !=0: error code */
 			res = dir_find(dj);				/* Find it */
 			ns = *(dj->fn+NS);
 			if (res != FR_OK) {				/* Failed to find the object */
-				if (res != FR_NO_FILE) break;	/* Abort if any hard error occured */
+				if (res != FR_NO_FILE) break;	/* Abort if any hard error occurred */
 				/* Object not found */
 				if (_FS_RPATH && (ns & NS_DOT)) {	/* If dot entry is not exit */
 					dj->sclust = 0; dj->dir = 0;	/* It is the root dir */
@@ -1710,7 +1710,7 @@ FRESULT chk_mounted (	/* FR_OK(0): successful, !=0: any error occurred */
 	if (chk_wp && (stat & STA_PROTECT))	/* Check disk write protection if needed */
 		return FR_WRITE_PROTECTED;
 #endif
-	/* Search FAT partition on the drive (Supports only generic partitionings, FDISK and SFD) */
+	/* Search FAT partition on the drive (Supports only generic partitions, FDISK and SFD) */
 	fmt = check_fs(fs, bsect = 0);		/* Check sector 0 if it is a VBR */
 	if (fmt == 1) {						/* Not an FAT-VBR, the disk may be partitioned */
 		/* Check the partition listed in top of the partition table */
@@ -2527,7 +2527,7 @@ FRESULT f_lseek (
 
 #if _FS_MINIMIZE <= 1
 /*-----------------------------------------------------------------------*/
-/* Create a Directroy Object                                             */
+/* Create a Directory Object                                             */
 /*-----------------------------------------------------------------------*/
 
 FRESULT f_opendir (
@@ -2569,7 +2569,7 @@ FRESULT f_opendir (
 
 
 /*-----------------------------------------------------------------------*/
-/* Read Directory Entry in Sequense                                      */
+/* Read Directory Entry in Sequence                                      */
 /*-----------------------------------------------------------------------*/
 
 FRESULT f_readdir (
@@ -2878,7 +2878,7 @@ FRESULT f_mkdir (
 					mem_set(dir, 0, SS(dj.fs));
 				}
 			}
-			if (res == FR_OK) res = dir_register(&dj);	/* Register the object to the directoy */
+			if (res == FR_OK) res = dir_register(&dj);	/* Register the object to the directory */
 			if (res != FR_OK) {
 				remove_chain(dj.fs, dcl);				/* Could not register, remove cluster chain */
 			} else {
@@ -2943,7 +2943,7 @@ FRESULT f_chmod (
 
 
 /*-----------------------------------------------------------------------*/
-/* Change Timestamp                                                      */
+/* Change Time-stamp                                                      */
 /*-----------------------------------------------------------------------*/
 
 FRESULT f_utime (
@@ -3361,18 +3361,18 @@ TCHAR* f_gets (
 #if _LFN_UNICODE					/* Read a character in UTF-8 encoding */
 		if (c >= 0x80) {
 			if (c < 0xC0) continue;	/* Skip stray trailer */
-			if (c < 0xE0) {			/* Two-byte sequense */
+			if (c < 0xE0) {			/* Two-byte sequence */
 				f_read(fil, s, 1, &rc);
 				if (rc != 1) break;
 				c = ((c & 0x1F) << 6) | (s[0] & 0x3F);
 				if (c < 0x80) c = '?';
 			} else {
-				if (c < 0xF0) {		/* Three-byte sequense */
+				if (c < 0xF0) {		/* Three-byte sequence */
 					f_read(fil, s, 2, &rc);
 					if (rc != 2) break;
 					c = (c << 12) | ((s[0] & 0x3F) << 6) | (s[1] & 0x3F);
 					if (c < 0x800) c = '?';
-				} else {			/* Reject four-byte sequense */
+				} else {			/* Reject four-byte sequence */
 					c = '?';
 				}
 			}
@@ -3510,7 +3510,7 @@ int f_printf (
 		case 'D' :					/* Signed decimal */
 		case 'U' :					/* Unsigned decimal */
 			r = 10; break;
-		case 'X' :					/* Hexdecimal */
+		case 'X' :					/* Hexadecimal */
 			r = 16; break;
 		default:					/* Unknown */
 			cc = f_putc(c, fil); continue;

Projects/Webserver/Lib/FATFs/ffconf.h

@@ -113,7 +113,7 @@
 #define _FS_RPATH	0		/* 0:Disable or 1:Enable */
 /* When _FS_RPATH is set to 1, relative path feature is enabled and f_chdir,
 /  f_chdrive function are available.
-/  Note that output of the f_readdir fnction is affected by this option. */
+/  Note that output of the f_readdir function is affected by this option. */
 
 
 
@@ -129,7 +129,7 @@
 /* Maximum sector size to be handled.
 /  Always set 512 for memory card and hard disk but a larger value may be
 /  required for floppy disk (512/1024) and optical disk (512/2048).
-/  When _MAX_SS is larger than 512, GET_SECTOR_SIZE command must be implememted
+/  When _MAX_SS is larger than 512, GET_SECTOR_SIZE command must be implemented
 /  to the disk_ioctl function. */
 
 
@@ -172,7 +172,7 @@
 
 
 #define	_FS_SHARE	0	/* 0:Disable or >=1:Enable */
-/* To enable file shareing feature, set _FS_SHARE to >= 1 and also user
+/* To enable file sharing feature, set _FS_SHARE to >= 1 and also user
    provided memory handlers, ff_memalloc and ff_memfree function must be
    added to the project. The value defines number of files can be opened
    per volume. */

Projects/Webserver/Lib/HTTPServerApp.c

@@ -77,7 +77,7 @@ const MIME_Type_t MIMETypes[] =
 		{.Extension = "pdf", .MIMEType = "application/pdf"},
 	};
 
-/** FATFs structure to hold the internal state of the FAT driver for the dataflash contents. */
+/** FATFs structure to hold the internal state of the FAT driver for the Dataflash contents. */
 FATFS DiskFATState;
 
 
@@ -87,7 +87,7 @@ void HTTPServerApp_Init(void)
 	/* Listen on port 80 for HTTP connections from hosts */
 	uip_listen(HTONS(HTTP_SERVER_PORT));
 	
-	/* Mount the dataflash disk via FatFS */
+	/* Mount the Dataflash disk via FatFS */
 	f_mount(0, &DiskFATState);
 }
 

Projects/Webserver/Lib/SCSI.c

@@ -241,7 +241,7 @@ static void SCSI_Command_Send_Diagnostic(USB_ClassInfo_MS_Device_t* const MSInte
 }
 
 /** Command processing for an issued SCSI READ (10) or WRITE (10) command. This command reads in the block start address
- *  and total number of blocks to process, then calls the appropriate low-level dataflash routine to handle the actual
+ *  and total number of blocks to process, then calls the appropriate low-level Dataflash routine to handle the actual
  *  reading and writing of the data.
  *
  *  \param[in] MSInterfaceInfo  Pointer to the Mass Storage class interface structure that the command is associated with

Projects/Webserver/Lib/uip/timer.c

@@ -94,7 +94,7 @@ timer_reset(struct timer *t)
  * current time.
  *
  * \note A periodic timer will drift if this function is used to reset
- * it. For preioric timers, use the timer_reset() function instead.
+ * it. For periodic timers, use the timer_reset() function instead.
  *
  * \param t A pointer to the timer.
  *

Projects/Webserver/Lib/uip/uip-split.c

@@ -89,7 +89,7 @@ uip_split_output(void)
     /* Now, create the second packet. To do this, it is not enough to
        just alter the length field, but we must also update the TCP
        sequence number and point the uip_appdata to a new place in
-       memory. This place is detemined by the length of the first
+       memory. This place is determined by the length of the first
        packet (len1). */
     uip_len = len2 + UIP_TCPIP_HLEN + UIP_LLH_LEN;
 #if UIP_CONF_IPV6

Projects/Webserver/Lib/uip/uip_arp.c

@@ -364,7 +364,7 @@ uip_arp_out(void)
   struct arp_entry *tabptr = NULL;
   
   /* Find the destination IP address in the ARP table and construct
-     the Ethernet header. If the destination IP addres isn't on the
+     the Ethernet header. If the destination IP address isn't on the
      local network, we use the default router's IP address instead.
 
      If not ARP table entry is found, we overwrite the original IP

Projects/Webserver/Webserver.txt

@@ -63,13 +63,13 @@
  *  device being used for this project to work if the DHCP client is disabled (see \ref SSec_Options) - otherwise, the device
  *  will query the network's DHCP server for these parameters automatically.
  *
- *  When properly configured, the webserver can be accessed from any HTTP webrowser by typing in the device's statically or
+ *  When properly configured, the webserver can be accessed from any HTTP web browser by typing in the device's statically or
  *  dynamically allocated IP address. The TELNET client can be accessed via any network socket app by connecting to the device
  *  on port 23 on the device's statically or dynamically allocated IP address.
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this project, which can control the project behaviour when defined, or changed in value.
+ *  The following defines can be found in this project, which can control the project behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>
@@ -107,7 +107,7 @@
  *   <tr>
  *    <td>MAX_URI_LENGTH</td>
  *    <td>Makefile LUFA_OPTS</td>
- *    <td>Maximum length of a URI for the Webserver. This is the maximum file path, including subdirectories and seperators.</td>
+ *    <td>Maximum length of a URI for the Webserver. This is the maximum file path, including subdirectories and separators.</td>
  *   </tr>
  *  </table>
  */

Projects/XPLAINBridge/XPLAINBridge.txt

@@ -47,7 +47,7 @@
  *  \section SSec_Description Project Description: 
  *
  *  This project serves a dual purpose. When loaded into the USB AVR on the XPLAIN board, it will act as either a USB to Serial
- *  converter for the XPLAIN's hardware USART (at a speed of 9600 baud), or an AVRStudio compaible PDI programmer for the XMEGA.
+ *  converter for the XPLAIN's hardware USART (at a speed of 9600 baud), or an AVRStudio compatible PDI programmer for the XMEGA.
  *  This project replaces the firmware preloaded onto the XPLAIN's onboard AT90USB1287 microcontroller.
  *
  *  When power to the board is applied, the TDI pin (pin 9) of the USB AVR's JTAG port is read. If the pin is left high, the device
@@ -70,7 +70,7 @@
  *
  *  \section SSec_Options Project Options
  *
- *  The following defines can be found in this project, which can control the project behaviour when defined, or changed in value.
+ *  The following defines can be found in this project, which can control the project behavior when defined, or changed in value.
  *
  *  <table>
  *   <tr>

README.txt

@@ -26,7 +26,7 @@ quick and easy creation of complex USB devices and hosts.
 To get started, you will need to install the "Doxygen" documentation
 generation tool. If you use Linux, this can be installed via the "doxygen"
 package in your chosen package management tool - under Ubuntu, this can be
-acheived by running the following command in the terminal:
+achieved by running the following command in the terminal:
 
    sudo apt-get install doxygen