forksand
/
qmk_firmware
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

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

Browse Source
pull/1469/head
Dean Camera 14 years ago
parent ca007f91f2
commit 28401f7bb7
116 changed files with 600 additions and 600 deletions
Show Stats Download Patch File Download Diff File

4
Bootloaders/CDC/BootloaderCDC.txt
Unescape View File

@ -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>
@ -69,4 +69,4 @@
* </td>
* </tr>
* </table>
*/
*/

2
Bootloaders/DFU/BootloaderDFU.txt
Unescape View File

@ -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>

2
Demos/Device/ClassDriver/AudioInput/AudioInput.txt
Unescape View File

@ -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>

2
Demos/Device/ClassDriver/AudioOutput/AudioOutput.c
Unescape View File

@ -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
}

2
Demos/Device/ClassDriver/AudioOutput/AudioOutput.txt
Unescape View File

@ -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>

4
Demos/Device/ClassDriver/DualVirtualSerial/DualVirtualSerial.txt
Unescape View File

@ -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>
@ -82,4 +82,4 @@
* </td>
* </tr>
* </table>
*/
*/

2
Demos/Device/ClassDriver/GenericHID/GenericHID.txt
Unescape View File

@ -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>

4
Demos/Device/ClassDriver/Joystick/Joystick.txt
Unescape View File

@ -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>
@ -70,4 +70,4 @@
* </td>
* </tr>
* </table>
*/
*/

4
Demos/Device/ClassDriver/Keyboard/Keyboard.txt
Unescape View File

@ -55,12 +55,12 @@
* when the USB connection to a host is present. To use the keyboard example,
* manipulate the joystick to send the letters a, b, c, d and e. See the USB HID
* documentation for more information on sending keyboard event and key presses. Unlike
* other LUFA Keyboard demos, this example shows explicitly how to send multiple keypresses
* other LUFA Keyboard demos, this example shows explicitly how to send multiple key presses
* inside the same report to the host.
*
* \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>

2
Demos/Device/ClassDriver/KeyboardMouse/KeyboardMouse.txt
Unescape View File

@ -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>

2
Demos/Device/ClassDriver/MIDI/MIDI.txt
Unescape View File

@ -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>

122
Demos/Device/ClassDriver/MassStorage/Lib/DataflashManager.c
Unescape View File

@ -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.
* Dataflash in Dataflash page sized blocks. This can be linked to FAT libraries to write files to the
* 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();
}

2
Demos/Device/ClassDriver/MassStorage/Lib/DataflashManager.h
Unescape View File

@ -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

2
Demos/Device/ClassDriver/MassStorage/Lib/SCSI.c
Unescape View File

@ -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

2
Demos/Device/ClassDriver/MassStorage/MassStorage.txt
Unescape View File

@ -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>

122
Demos/Device/ClassDriver/MassStorageKeyboard/Lib/DataflashManager.c
Unescape View File

@ -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.
* Dataflash in Dataflash page sized blocks. This can be linked to FAT libraries to write files to the
* 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();
}

2
Demos/Device/ClassDriver/MassStorageKeyboard/Lib/DataflashManager.h
Unescape View File

@ -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

2
Demos/Device/ClassDriver/MassStorageKeyboard/Lib/SCSI.c
Unescape View File

@ -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

2
Demos/Device/ClassDriver/MassStorageKeyboard/MassStorageKeyboard.txt
Unescape View File

@ -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>

2
Demos/Device/ClassDriver/Mouse/Mouse.txt
Unescape View File

@ -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>

2
Demos/Device/ClassDriver/RNDISEthernet/Lib/Ethernet.c
Unescape View File

@ -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.
*/

4
Demos/Device/ClassDriver/RNDISEthernet/RNDISEthernet.txt
Unescape View File

@ -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>
@ -119,4 +119,4 @@
* <td>When defined, received DHCP headers will not be decoded and printed to the device serial port.</td>
* </tr>
* </table>
*/
*/

4
Demos/Device/ClassDriver/VirtualSerial/VirtualSerial.txt
Unescape View File

@ -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>
@ -69,4 +69,4 @@
* </td>
* </tr>
* </table>
*/
*/

4
Demos/Device/ClassDriver/VirtualSerialMouse/VirtualSerialMouse.txt
Unescape View File

@ -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>
@ -73,4 +73,4 @@
* </td>
* </tr>
* </table>
*/
*/

4
Demos/Device/Incomplete/Sideshow/Descriptors.c
Unescape View File

@ -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;
@ -229,4 +229,4 @@ uint16_t USB_GetOSFeatureDescriptor(const uint16_t wValue,
*DescriptorAddress = Address;
return Size;
}
}

26
Demos/Device/Incomplete/TestAndMeasurement/TestAndMeasurement.c
Unescape View File

@ -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);

2
Demos/Device/LowLevel/AudioInput/AudioInput.txt
Unescape View File

@ -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>

2
Demos/Device/LowLevel/AudioOutput/AudioOutput.c
Unescape View File

@ -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
}

2
Demos/Device/LowLevel/AudioOutput/AudioOutput.txt
Unescape View File

@ -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>

4
Demos/Device/LowLevel/DualVirtualSerial/DualVirtualSerial.txt
Unescape View File

@ -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>
@ -82,4 +82,4 @@
* </td>
* </tr>
* </table>
*/
*/

2
Demos/Device/LowLevel/GenericHID/GenericHID.txt
Unescape View File

@ -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>

4
Demos/Device/LowLevel/Joystick/Joystick.txt
Unescape View File

@ -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>
@ -70,4 +70,4 @@
* </td>
* </tr>
* </table>
*/
*/

4
Demos/Device/LowLevel/Keyboard/Keyboard.txt
Unescape View File

@ -55,12 +55,12 @@
* when the USB connection to a host is present. To use the keyboard example,
* manipulate the joystick to send the letters a, b, c, d and e. See the USB HID
* documentation for more information on sending keyboard event and key presses. Unlike
* other LUFA Keyboard demos, this example shows explicitly how to send multiple keypresses
* other LUFA Keyboard demos, this example shows explicitly how to send multiple key presses
* inside the same report to the host.
*
* \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>

2
Demos/Device/LowLevel/KeyboardMouse/KeyboardMouse.c
Unescape View File

@ -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)
{

2
Demos/Device/LowLevel/KeyboardMouse/KeyboardMouse.txt
Unescape View File

@ -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>

2
Demos/Device/LowLevel/MIDI/MIDI.txt
Unescape View File

@ -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>

122
Demos/Device/LowLevel/MassStorage/Lib/DataflashManager.c
Unescape View File

@ -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.
* Dataflash in Dataflash page sized blocks. This can be linked to FAT libraries to write files to the
* 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();
}

2
Demos/Device/LowLevel/MassStorage/Lib/DataflashManager.h
Unescape View File

@ -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

2
Demos/Device/LowLevel/MassStorage/Lib/SCSI.c
Unescape View File

@ -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)

2
Demos/Device/LowLevel/MassStorage/MassStorage.txt
Unescape View File

@ -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>

2
Demos/Device/LowLevel/Mouse/Mouse.txt
Unescape View File

@ -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>

4
Demos/Device/LowLevel/RNDISEthernet/Lib/RNDIS.h
Unescape View File

@ -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;

4
Demos/Device/LowLevel/RNDISEthernet/RNDISEthernet.txt
Unescape View File

@ -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>
@ -119,4 +119,4 @@
* <td>When defined, received DHCP headers will not be decoded and printed to the device serial port.</td>
* </tr>
* </table>
*/
*/

4
Demos/Device/LowLevel/VirtualSerial/VirtualSerial.txt
Unescape View File

@ -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>
@ -69,4 +69,4 @@
* </td>
* </tr>
* </table>
*/
*/

2
Demos/DualRole/ClassDriver/MouseHostDevice/MouseHostDevice.txt
Unescape View File

@ -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>

4
Demos/Host/ClassDriver/JoystickHostWithParser/JoystickHostWithParser.txt
Unescape View File

@ -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>
@ -67,4 +67,4 @@
* </td>
* </tr>
* </table>
*/
*/

2
Demos/Host/ClassDriver/KeyboardHost/KeyboardHost.txt
Unescape View File

@ -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>

6
Demos/Host/ClassDriver/KeyboardHostWithParser/KeyboardHostWithParser.c
Unescape View File

@ -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;
}
}

4
Demos/Host/ClassDriver/KeyboardHostWithParser/KeyboardHostWithParser.txt
Unescape View File

@ -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>
@ -67,4 +67,4 @@
* </td>
* </tr>
* </table>
*/
*/

2
Demos/Host/ClassDriver/MIDIHost/MIDIHost.txt
Unescape View File

@ -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>

4
Demos/Host/ClassDriver/MassStorageHost/MassStorageHost.txt
Unescape View File

@ -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>
@ -64,4 +64,4 @@
* </td>
* </tr>
* </table>
*/
*/

2
Demos/Host/ClassDriver/MouseHost/MouseHost.txt
Unescape View File

@ -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>

4
Demos/Host/ClassDriver/MouseHostWithParser/MouseHostWithParser.txt
Unescape View File

@ -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>
@ -67,4 +67,4 @@
* </td>
* </tr>
* </table>
*/
*/

4
Demos/Host/ClassDriver/PrinterHost/PrinterHost.txt
Unescape View File

@ -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>
@ -62,4 +62,4 @@
* </td>
* </tr>
* </table>
*/
*/

4
Demos/Host/ClassDriver/RNDISEthernetHost/RNDISEthernetHost.txt
Unescape View File

@ -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>
@ -59,4 +59,4 @@
* </td>
* </tr>
* </table>
*/
*/

4
Demos/Host/ClassDriver/StillImageHost/StillImageHost.txt
Unescape View File

@ -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>
@ -61,4 +61,4 @@
* </td>
* </tr>
* </table>
*/
*/

2
Demos/Host/ClassDriver/VirtualSerialHost/VirtualSerialHost.txt
Unescape View File

@ -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>

2
Demos/Host/Incomplete/BluetoothHost/Lib/RFCOMM.c
Unescape View File

@ -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);
}

2
Demos/Host/Incomplete/BluetoothHost/Lib/SDP.c
Unescape View File

@ -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

2
Demos/Host/LowLevel/GenericHIDHost/GenericHIDHost.txt
Unescape View File

@ -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>

4
Demos/Host/LowLevel/JoystickHostWithParser/JoystickHostWithParser.txt
Unescape View File

@ -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>
@ -67,4 +67,4 @@
* </td>
* </tr>
* </table>
*/
*/

2
Demos/Host/LowLevel/KeyboardHost/KeyboardHost.txt
Unescape View File

@ -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>

10
Demos/Host/LowLevel/KeyboardHostWithParser/KeyboardHostWithParser.c
Unescape View File

@ -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;
}
}

4
Demos/Host/LowLevel/KeyboardHostWithParser/KeyboardHostWithParser.txt
Unescape View File

@ -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>
@ -67,4 +67,4 @@
* </td>
* </tr>
* </table>
*/
*/

2
Demos/Host/LowLevel/MIDIHost/MIDIHost.txt
Unescape View File

@ -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>

4
Demos/Host/LowLevel/MassStorageHost/MassStorageHost.txt
Unescape View File

@ -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>
@ -64,4 +64,4 @@
* </td>
* </tr>
* </table>
*/
*/

2
Demos/Host/LowLevel/MouseHost/MouseHost.txt
Unescape View File

@ -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>

4
Demos/Host/LowLevel/MouseHostWithParser/MouseHostWithParser.txt
Unescape View File

@ -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>
@ -67,4 +67,4 @@
* </td>
* </tr>
* </table>
*/
*/

4
Demos/Host/LowLevel/PrinterHost/PrinterHost.txt
Unescape View File

@ -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>
@ -59,4 +59,4 @@
* </td>
* </tr>
* </table>
*/
*/

8
Demos/Host/LowLevel/RNDISEthernetHost/Lib/RNDISCommands.c
Unescape View File

@ -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;
}

4
Demos/Host/LowLevel/RNDISEthernetHost/Lib/RNDISCommands.h
Unescape View File

@ -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;

4
Demos/Host/LowLevel/RNDISEthernetHost/RNDISHost.txt
Unescape View File

@ -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>
@ -59,4 +59,4 @@
* </td>
* </tr>
* </table>
*/
*/

4
Demos/Host/LowLevel/StillImageHost/StillImageHost.txt
Unescape View File

@ -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>
@ -61,4 +61,4 @@
* </td>
* </tr>
* </table>
*/
*/

2
Demos/Host/LowLevel/VirtualSerialHost/VirtualSerialHost.txt
Unescape View File

@ -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>

2
LUFA/Common/Common.h
Unescape View File

@ -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.
*

4
LUFA/DriverStubs/Dataflash.h
Unescape View File

@ -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

2
LUFA/Drivers/USB/HighLevel/StdDescriptors.h
Unescape View File

@ -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.

12
LUFA/Drivers/USB/USB.h
Unescape View File

@ -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
* takes in the address of the specific instance you wish to initialize - in this manner, multiple seperate instances of
* 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 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)

14
LUFA/ManPages/ChangeLog.txt
Unescape View File

@ -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
* behaviour of the command line tools used to perform the check on each platform
* - Removed the automated checking of event names in the demo, project and bootloader makefiles due to inconsistencies between the
* 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
*

2
LUFA/ManPages/LUFAvsAtmelStack.txt
Unescape View File

@ -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.
*

2
LUFA/ManPages/SoftwareBootloaderJump.txt
Unescape View File

@ -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

4
Projects/AVRISP-MKII/AVRISP-MKII.txt
Unescape View File

@ -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>

4
Projects/Benito/Benito.txt
Unescape View File

@ -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>

2
Projects/Incomplete/MIDIToneGenerator/MIDIToneGenerator.c
Unescape View File

@ -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. */

122
Projects/Incomplete/StandaloneProgrammer/Lib/DataflashManager.c
Unescape View File

@ -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.
* Dataflash in Dataflash page sized blocks. This can be linked to FAT libraries to write files to the
* 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();
}

4
Projects/Incomplete/StandaloneProgrammer/Lib/PetiteFATFs/diskio.h
Unescape View File

@ -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;

18
Projects/Incomplete/StandaloneProgrammer/Lib/PetiteFATFs/pff.c
Unescape View File

@ -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 (

2
Projects/Incomplete/StandaloneProgrammer/Lib/SCSI.c
Unescape View File

@ -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

4
Projects/Incomplete/StandaloneProgrammer/StandaloneProgrammer.c
Unescape View File

@ -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)
{

4
Projects/LEDNotifier/LEDNotifier.txt
Unescape View File

@ -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>
@ -59,4 +59,4 @@
* </td>
* </tr>
* </table>
*/
*/

2
Projects/Magstripe/Magstripe.txt
Unescape View File

@ -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>

2
Projects/MissileLauncher/MissileLauncher.txt
Unescape View File

@ -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>

122
Projects/TempDataLogger/Lib/DataflashManager.c
Unescape View File

@ -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.
* Dataflash in Dataflash page sized blocks. This can be linked to FAT libraries to write files to the
* 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();
}

6
Projects/TempDataLogger/Lib/FATFs/00readme.txt
Unescape View File

@ -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.

12
Projects/TempDataLogger/Lib/FATFs/diskio.c
Unescape View File

@ -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 */
)

2
Projects/TempDataLogger/Lib/FATFs/diskio.h
Unescape View File

@ -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

16
Projects/TempDataLogger/Lib/FATFs/ff.c
Unescape View File

@ -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;

12
Projects/TempDataLogger/Lib/FATFs/ffconf.h
Unescape View File

@ -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. */

2
Projects/TempDataLogger/Lib/SCSI.c
Unescape View File

@ -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

6
Projects/TempDataLogger/TempDataLogger.c
Unescape View File

@ -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();
}

2
Projects/TempDataLogger/TemperatureDataLogger.txt
Unescape View File

@ -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>

4
Projects/USBtoSerial/USBtoSerial.txt
Unescape View File

@ -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>
@ -79,4 +79,4 @@
* <td>Defines the maximum number of bytes which can be buffered in each Ring Buffer.</td>
* </tr>
* </table>
*/
*/

122
Projects/Webserver/Lib/DataflashManager.c
Unescape View File

@ -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.
* Dataflash in Dataflash page sized blocks. This can be linked to FAT libraries to write files to the
* 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();
}

6
Projects/Webserver/Lib/FATFs/00readme.txt
Unescape View File

@ -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.

10
Projects/Webserver/Lib/FATFs/diskio.c
Unescape View File

@ -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) */

2
Projects/Webserver/Lib/FATFs/diskio.h
Unescape View File

@ -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

24
Projects/Webserver/Lib/FATFs/ff.c
Unescape View File

@ -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;

6
Projects/Webserver/Lib/FATFs/ffconf.h
Unescape View File

@ -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. */

4
Projects/Webserver/Lib/HTTPServerApp.c
Unescape View File

@ -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);
}

2
Projects/Webserver/Lib/SCSI.c
Unescape View File

@ -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

2
Projects/Webserver/Lib/uip/timer.c
Unescape View File

@ -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.
*

2
Projects/Webserver/Lib/uip/uip-split.c
Unescape View File

@ -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

2
Projects/Webserver/Lib/uip/uip_arp.c
Unescape View File

@ -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

10
Projects/Webserver/Webserver.txt
Unescape View File

@ -48,7 +48,7 @@
* \section SSec_Description Project Description:
*
* Simple HTTP webserver project. This project combines the LUFA library with the uIP TCP/IP full network stack and FatFS
* library to create a RNDIS host capable of serving out HTTP webpages to multiple hosts simultaneously. This project
* library to create a RNDIS host capable of serving out HTTP web pages to multiple hosts simultaneously. This project
* demonstrates how the libraries can be combined into a robust network enabled application, with the addition of a RNDIS
* network device.
*
@ -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>
*/
*/

6
Projects/XPLAINBridge/XPLAINBridge.txt
Unescape View File

@ -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>
@ -90,4 +90,4 @@
* the code compatible with software such as avrdude (all platforms) that use the libUSB driver.
* </tr>
* </table>
*/
*/

4
README.txt
Unescape View File

@ -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
@ -49,4 +49,4 @@ created Documentation/html/ subdirectories inside each project folder.
The documentation for the library itself (but not the documentation for the
individual demos, projects or bootloaders) is also available as a separate
package from the project webpage for convenience if Doxygen cannot be
installed.
installed.

Write Preview
Loading…
Cancel
Save