Sujet Précédent Sujet Suivant

Dialogue USB

marcus112 Messages postés 7 Date d'inscription lundi 31 janvier 2011 Statut Membre Dernière intervention 8 juin 2011 - 25 mai 2011 à 17:15
marcus112 Messages postés 7 Date d'inscription lundi 31 janvier 2011 Statut Membre Dernière intervention 8 juin 2011 - 8 juin 2011 à 09:22
Bonjour à tous,

comment est-ce que je peux à partir d'une commande (un appuie bouton ou une variable qui passe à 1), faire transférer un fichier (dont je connais l'adresse) sur une clé usb qui serait branché.

je ne veux pas passer par une fenêtre windows mais être sur que le fichier est bien sur ma clé. (à lire sur un autre ordi par exemple)

si quelqu'un a une idée du code à réaliser...

merci à chacun(e) pour l'aide que vous pourrez m'apporter.

9 réponses

Réponse 1 / 9
draonix Messages postés 43 Date d'inscription mercredi 27 mai 2009 Statut Membre Dernière intervention 7 juin 2011
26 mai 2011 à 18:30
Bonjour Bonjour,

Si tu connais l'addresse c'est génial. Cependant le code sera différents entre les OS que tu utiliseras.

Sur linux tu dois utiliser :

cp [le chemin du fichier ou dossier à copier] [le chemin du fichier où tu veux qu'il soit copié]

et sous windows ce sera plutot :

copy [le chemin du fichier ou dossier à copier] [le chemin du fichier où tu veux qu'il soit copié]

et pour faire celà tu as une fonction génial sous C++ et C par la même occasion qui s'appelle "system"clique ici pour plus d'info

J'espère que tu ne seras pas dérouter par l'anglais.

Avant que je n'oublie la fonction se trouve dans la lib "cstdlib"
++
0
Réponse 2 / 9
marcus112 Messages postés 7 Date d'inscription lundi 31 janvier 2011 Statut Membre Dernière intervention 8 juin 2011
27 mai 2011 à 09:47
pour répondre à ta question implicite, je travail avec IAR embedded workbench. C'est un logiciel de programmation en C pour microcontroleur.

je ne suis donc pas sous linux...
merci pour t'es info, j'espère que la librairie sera présente dans mon logiciel parce que sinon je ne pourrais pas utiliser ce que tu m'as présenté.
0
Réponse 3 / 9
marcus112 Messages postés 7 Date d'inscription lundi 31 janvier 2011 Statut Membre Dernière intervention 8 juin 2011
27 mai 2011 à 10:58
après avoir regardé ce que tu m'as passé, la commande "copy" me demande donc forcément le chemin de destination. et là c'est un problème.

si la clé s'appelle "maman" ou "papa" ça sera donc pas le même chemin...
je ne pourrai donc pas créer un code qui marchera à tout les coups.
0
Réponse 4 / 9
draonix Messages postés 43 Date d'inscription mercredi 27 mai 2009 Statut Membre Dernière intervention 7 juin 2011
27 mai 2011 à 16:35
Bonjour Bonjour,

Bon du coup, la clé USB la branches tu sur ton PC ou bien directement au micro controleur ?
Si c'est sur le micro, il va falloir que tu regardes du coté des librairies et je ne pourrais pas forcément :s
0

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
Réponse 5 / 9
marcus112 Messages postés 7 Date d'inscription lundi 31 janvier 2011 Statut Membre Dernière intervention 8 juin 2011
7 juin 2011 à 12:02
Sur le site :
http://www.rennes.supelec.fr/ren/fi/elec/docs/usb/usb.html

au chapitre 2 il est dit que l'envoi de donnée doit se faire due D+ et D-.
Je pense donc que je doit envoyer des datas sur D+ et D- simultanément afin de pouvoir transférer quoi que ce soit.

Ce pendant un peu plus bas il est aussi dit que le protocole s'exécute dans cet ordre:
- un paquet Jeton (Token)
- un paquet de données (DATA)
- un paquet d'état (HandShake)


ma question est donc, comment réaliser cela simplement?
Quels moyens de faire?
Est-ce que j'ai dit des bétises?

merci
0
Réponse 6 / 9
draonix Messages postés 43 Date d'inscription mercredi 27 mai 2009 Statut Membre Dernière intervention 7 juin 2011
7 juin 2011 à 14:38
Bonjour,

J'ai déjà travaillé sur le port USB avec un micro-controller en C c'était un PIC 18F et je me rappelle avoir utilisé une librairie spéciale. Ce que tu dis est juste mais je pense qu'il doit exister des librairies spéciales pour ce que tu cherches à faire. Je sais que j'en avais une de fournie avec le constructeur Micro-chip et que pour certains projet tu peux utiliser la libUSB Tapez le texte de l'url ici.. Je te conseillerai de voir si il n'existe pas de librarie constructeurs car pour chaque constructeur correspond des periphériques spéciaux du coup je ne peux pas t'aider outre mesure.
0
Réponse 7 / 9
marcus112 Messages postés 7 Date d'inscription lundi 31 janvier 2011 Statut Membre Dernière intervention 8 juin 2011
7 juin 2011 à 14:45
comment est-ce que je peux mettre des pièces jointes tel quel des bloc notes.

J'en ai 4 que j'aimerais t'envoyer parce que je pense qu'il y a tout ce qu'il faut mais je n'arrive pas à faire fonctionner avec malgrès ça.

C'était pour avoir un avis...
0
Réponse 8 / 9
draonix Messages postés 43 Date d'inscription mercredi 27 mai 2009 Statut Membre Dernière intervention 7 juin 2011
7 juin 2011 à 21:24
Fais juste un copier/coller des fichiers et mets les codes ...
Comme ça tous le monde pourra donner son avis et si une personne rencontre le même problème que toi qu'il puisse s'inspirer de ce que tu as fait ...

++
0
Réponse 9 / 9
marcus112 Messages postés 7 Date d'inscription lundi 31 janvier 2011 Statut Membre Dernière intervention 8 juin 2011
8 juin 2011 à 09:22
/*************************************************************************
* Function Name: USB_IO_Data
* Parameters: USB_Endpoint_t EP, pInt8U pBuffer, Int32U Size, void * pFn
*
* Return: USB_IO_Status_t
*
* Description: Prepare and send
*
*************************************************************************/
USB_IO_Status_t USB_IO_Data (USB_Endpoint_t EP, pInt8U pBuffer, Int32U Size, void * pFn)
{
#if __CORE__ < 7
Int32U Save;
#endif // __CORE__ < 7

pEpCnfg_t pEP = &EpCnfg[EP];

if (Size == (Int32U)-1)
{
pEP->Status = NOT_READY;
pEP->pFn = NULL;
}
else
{
#if __CORE__ < 7
ENTR_CRT_SECTION(Save);
#else
ENTR_CRT_SECTION();
#endif // __CORE__ < 7
if (!USB_EP_VALID(pEP))
{
#if __CORE__ < 7
EXT_CRT_SECTION(Save);
#else
EXT_CRT_SECTION();
#endif // __CORE__ < 7
return(NOT_VALID);
}
// lock buffer
if(pEP->Status == BEGIN_SERVICED)
{
#if __CORE__ < 7
EXT_CRT_SECTION(Save);
#else
EXT_CRT_SECTION();
#endif // __CORE__ < 7
return(NOT_READY);
}
pEP->Offset = 0;
pEP->pBuffer = pBuffer;
pEP->pFn = pFn;
if(!(pEP->Size = Size))
{
pEP->bZeroPacket = 1;
}
pEP->Status = NO_SERVICED;
USB_EP_IO(EP);
#if __CORE__ < 7
EXT_CRT_SECTION(Save);
#else
EXT_CRT_SECTION();
#endif // __CORE__ < 7
}
return(pEP->Status);
}


/*************************************************************************
* Function Name: USB_HwInit
* Parameters: none
*
* Return: none
*
* Description: Init USB
*
*************************************************************************/
void USB_HwInit(void)
{
NVIC_InitTypeDef NVIC_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;

// GPIO assign to the USB engine
RCC_APB2PeriphResetCmd( RCC_APB2Periph_GPIOA
| RCC_APB2Periph_GPIOD
| RCC_APB2Periph_AFIO, DISABLE);
RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA
| RCC_APB2Periph_GPIOD
| RCC_APB2Periph_AFIO, ENABLE);

// Power Control
GPIO_SetBits(GPIOD,GPIO_Pin_7);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOD, &GPIO_InitStructure);

// VBUS, ID
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9 | GPIO_Pin_10 ;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);

// DM, DP
// Configure PA11, PA12 as USB lines
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11 | GPIO_Pin_12;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);

// USBFSCLK = PLL1VCO / 3
RCC_OTGFSCLKConfig(USB_DIVIDER);
// Enable USB clock for USB FS OTG controller
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_OTG_FS, ENABLE) ;

// Deinit
RCC_AHBPeriphResetCmd(RCC_AHBPeriph_OTG_FS,ENABLE);
RCC_AHBPeriphResetCmd(RCC_AHBPeriph_OTG_FS,DISABLE);

OTG_DEV_Init();
OTGD_FS_EnableDevInt();

// Disconnect device
USB_ConnectRes(FALSE);

// Init controls endpoints
USB_HwReset();

// USB interrupt connect to NVIC
NVIC_InitStructure.NVIC_IRQChannel = OTG_FS_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = USB_INTR_LOW_PRIORITY;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);

OTGD_FS_EnableGlobalInt();
}

/*************************************************************************
* Function Name: USB_HwReset
* Parameters: none
*
* Return: none
*
* Description: Reset USB engine
*
*************************************************************************/
void USB_HwReset (void)
{
Int32U Count;

// Clear realized EP flag
for(Count = 0; Count < ENP_MAX_NUMB; Count++)
{
EpCnfg[Count].MaxSize = 0;
}
// USB_Configure
USB_Configure(FALSE);
// Control EP Init
USB_RealizeEp(&USB_CtrlEpDescr0,NULL,TRUE);
USB_RealizeEp(&USB_CtrlEpDescr1,NULL,TRUE);
}

/*************************************************************************
* Function Name: USB_RealizeEp
* Parameters: const UsbStandardEpDescriptor_t * pEP_Desc,
* const UsbEP_ExtData_t * pUsbEP_ExtData, Boolean Enable
*
* Return: USB_ErrorCodes_t
*
* Description: Enable or disable an endpoint
*
*************************************************************************/
USB_ErrorCodes_t USB_RealizeEp(const UsbStandardEpDescriptor_t * pEP_Desc,
const UsbEP_ExtData_t * pUsbEP_ExtData,
Boolean Enable)
{
USB_Endpoint_t EP;
pEpCnfg_t pEP;

assert(pEP_Desc);

EP = (USB_Endpoint_t)USB_EpLogToPhysAdd(pEP_Desc->bEndpointAddress);
pEP = &EpCnfg[EP];

if (Enable)
{
// Set EP status
pEP->Status = NOT_READY;
// Init EP flags
pEP->Flags = 0;
// Set endpoint type
pEP->EpType = (UsbEpTransferType_t)pEP_Desc->bmAttributes.TransferType;
// Init EP max packet size
pEP->MaxSize = pEP_Desc->wMaxPacketSize;
OTGD_FS_PCD_EP_Open((EP_DESCRIPTOR *)pEP_Desc);
}
else
{
pEP->MaxSize = 0;
OTGD_FS_PCD_EP_Close(pEP_Desc->bEndpointAddress);
}
return(USB_OK);
}

/*************************************************************************
* Function Name: USB_SetAdd
* Parameters: Int32U DevAdd - device address between 0 - 127
*
* Return: none
*
* Description: Set device address
*
*************************************************************************/
void USB_SetAdd(Int32U DevAdd)
{
OTGD_FS_PCD_EP_SetAddress(DevAdd);
}

/*************************************************************************
* Function Name: USB_ConnectRes
* Parameters: Boolean Conn
*
* Return: none
*
* Description: Enable Pull-Up resistor
*
*************************************************************************/
void USB_ConnectRes (Boolean Conn)
{
if(Conn)
{
USB_DevConnect();
}
else
{
USB_DevDisconnect();
}
}

#if USB_REMOTE_WAKEUP != 0
/*************************************************************************
* Function Name: USB_WakeUp
* Parameters: none
*
* Return: none
*
* Description: Wake up Usb
*
*************************************************************************/
void USB_WakeUp (void)
{
}
#endif // USB_REMOTE_WAKEUP != 0

/*************************************************************************
* Function Name: USB_GetDevStatus
* Parameters: USB_DevStatusReqType_t Type
*
* Return: Boolean
*
* Description: Return USB device status
*
*************************************************************************/
Boolean USB_GetDevStatus (USB_DevStatusReqType_t Type)
{
switch (Type)
{
case USB_DevConnectStatus:
return(TRUE);
}
return(FALSE);
}

/*************************************************************************
* Function Name: USB_SetStallEP
* Parameters: USB_Endpoint_t EP, Boolean Stall
*
* Return: USB_ErrorCodes_t
*
* Description: The endpoint stall/unstall
*
*************************************************************************/
USB_ErrorCodes_t USB_SetStallEP (USB_Endpoint_t EP, Boolean Stall)
{
if(Stall)
{
OTGD_FS_PCD_EP_Stall(USB_EpPhysToLogAdd(EP));
EpCnfg[EP].Status = STALLED;
}
else
{
OTGD_FS_PCD_EP_ClrStall(USB_EpPhysToLogAdd(EP));
EpCnfg[EP].Status = NOT_READY;
}
return(USB_OK);
}

/*************************************************************************
* Function Name: USB_StallCtrlEP
* Parameters: none
*
* Return: none
*
* Description: Stall both direction of the CTRL EP
*
*************************************************************************/
void USB_StallCtrlEP (void)
{
EpCnfg[CTRL_ENP_IN].Status = STALLED;
EpCnfg[CTRL_ENP_OUT].Status = STALLED;
USB_SetStallEP(CTRL_ENP_IN,TRUE);
USB_SetStallEP(CTRL_ENP_OUT,TRUE);
}

/*************************************************************************
* Function Name: USB_GetStallEP
* Parameters: USB_Endpoint_t EP, pBoolean pStall
*
* Return: USB_ErrorCodes_t
*
* Description: Get stall state of the endpoint
*
*************************************************************************/
USB_ErrorCodes_t USB_GetStallEP (USB_Endpoint_t EP, pBoolean pStall)
{
if (!USB_EP_VALID(&EpCnfg[EP]))
{
return(USB_EP_NOT_VALID);
}
*pStall STALLED EpCnfg[EP].Status;
return (USB_OK);
}

/*************************************************************************
* Function Name: USB_EP_IO
* Parameters: USB_Endpoint_t EndPoint
*
* Return: none
*
* Description: Endpoints IO
*
*************************************************************************/
void USB_EP_IO(USB_Endpoint_t EP)
{
pEpCnfg_t pEP = &EpCnfg[EP];
assert(USB_EP_VALID(pEP));

if(pEP->Status != NO_SERVICED)
{
return;
}

if(EP & 1)
{
// IN
// Set Status
pEP->Status = BEGIN_SERVICED;
OTGD_FS_PCD_EP_Write ( USB_EpPhysToLogAdd(EP),
pEP->pBuffer,
pEP->Size);
}
else
{
// OUT
pEP->Status = BEGIN_SERVICED;
OTGD_FS_PCD_EP_Read ( USB_EpPhysToLogAdd(EP),
pEP->pBuffer,
pEP->Size);
}
}

/*************************************************************************
* Function Name: USB_EpLogToPhysAdd
* Parameters: Int8U EpLogAdd
*
* Return: USB_Endpoint_t
*
* Description: Convert the logical to physical address
*
*************************************************************************/
USB_Endpoint_t USB_EpLogToPhysAdd (Int8U EpLogAdd)
{
USB_Endpoint_t Address = (USB_Endpoint_t)((EpLogAdd & 0x0F)<<1);
if(EpLogAdd & 0x80)
{
++Address;
}
return(Address);
}

/*************************************************************************
* Function Name: USB_EpPhysToLogAdd
* Parameters: USB_Endpoint_t EP
*
* Return: Int8U
*
* Description: Convert physical to logical address
*
*************************************************************************/
Int8U USB_EpPhysToLogAdd (USB_Endpoint_t EP)
{
Int8U Addr = EP >> 1;
if(EP & 1)
{
Addr |= 0x80;
}
return(Addr);
}

#if USB_SOF_EVENT > 0
/*************************************************************************
* Function Name: USB_GetFrameNumb
* Parameters: none
*
* Return: Int32U
*
* Description: Return current value of SOF number
*
*************************************************************************/
Int32U USB_GetFrameNumb (void)
{
return(0);
}
#endif // USB_SOF_EVENT > 0

/*************************************************************************
* Function Name: USB_StatusPhase
* Parameters: Boolean In
*
* Return: none
*
* Description: Prepare status phase
*
*************************************************************************/
void USB_StatusPhase (Boolean In)
{
if(In)
{
if(UsbEp0SetupPacket.bRequest == SET_ADDRESS)
{
USB_SetAdd(UsbEp0SetupPacket.wValue.Lo);
}
USB_IO_Data(CTRL_ENP_IN,NULL,0,NULL);
}
else
{
USB_IO_Data(CTRL_ENP_OUT,NULL,0,NULL);
}
}


/**
* @brief Enables or disables the Half cycle flash access.
* @param FLASH_HalfCycleAccess: specifies the FLASH Half cycle Access mode.
* This parameter can be one of the following values:
* @arg FLASH_HalfCycleAccess_Enable: FLASH Half Cycle Enable
* @arg FLASH_HalfCycleAccess_Disable: FLASH Half Cycle Disable
* @retval None
*/
void FLASH_HalfCycleAccessCmd(uint32_t FLASH_HalfCycleAccess)
{
/* Check the parameters */
assert_param(IS_FLASH_HALFCYCLEACCESS_STATE(FLASH_HalfCycleAccess));

/* Enable or disable the Half cycle access */
FLASH->ACR &= ACR_HLFCYA_Mask;
FLASH->ACR |= FLASH_HalfCycleAccess;
}

/**
* @brief Enables or disables the Prefetch Buffer.
* @param FLASH_PrefetchBuffer: specifies the Prefetch buffer status.
* This parameter can be one of the following values:
* @arg FLASH_PrefetchBuffer_Enable: FLASH Prefetch Buffer Enable
* @arg FLASH_PrefetchBuffer_Disable: FLASH Prefetch Buffer Disable
* @retval None
*/
void FLASH_PrefetchBufferCmd(uint32_t FLASH_PrefetchBuffer)
{
/* Check the parameters */
assert_param(IS_FLASH_PREFETCHBUFFER_STATE(FLASH_PrefetchBuffer));

/* Enable or disable the Prefetch Buffer */
FLASH->ACR &= ACR_PRFTBE_Mask;
FLASH->ACR |= FLASH_PrefetchBuffer;
}

/**
* @brief Unlocks the FLASH Program Erase Controller.
* @param None
* @retval None
*/
void FLASH_Unlock(void)
{
/* Authorize the FPEC Access */
FLASH->KEYR = FLASH_KEY1;
FLASH->KEYR = FLASH_KEY2;
}

/**
* @brief Locks the FLASH Program Erase Controller.
* @param None
* @retval None
*/
void FLASH_Lock(void)
{
/* Set the Lock Bit to lock the FPEC and the FCR */
FLASH->CR |= CR_LOCK_Set;
}

/**
* @brief Erases a specified FLASH page.
* @param Page_Address: The page address to be erased.
* @retval FLASH Status: The returned value can be: FLASH_BUSY, FLASH_ERROR_PG,
* FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT.
*/
FLASH_Status FLASH_ErasePage(uint32_t Page_Address)
{
FLASH_Status status = FLASH_COMPLETE;
/* Check the parameters */
assert_param(IS_FLASH_ADDRESS(Page_Address));
/* Wait for last operation to be completed */
status = FLASH_WaitForLastOperation(EraseTimeout);

if(status == FLASH_COMPLETE)
{
/* if the previous operation is completed, proceed to erase the page */
FLASH->CR|= CR_PER_Set;
FLASH->AR = Page_Address;
FLASH->CR|= CR_STRT_Set;

/* Wait for last operation to be completed */
status = FLASH_WaitForLastOperation(EraseTimeout);
if(status != FLASH_TIMEOUT)
{
/* if the erase operation is completed, disable the PER Bit */
FLASH->CR &= CR_PER_Reset;
}
}
/* Return the Erase Status */
return status;
}

/**
* @brief Erases all FLASH pages.
* @param None
* @retval FLASH Status: The returned value can be: FLASH_ERROR_PG,
* FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT.
*/
FLASH_Status FLASH_EraseAllPages(void)
{
FLASH_Status status = FLASH_COMPLETE;
/* Wait for last operation to be completed */
status = FLASH_WaitForLastOperation(EraseTimeout);

if(status == FLASH_COMPLETE)
{
/* if the previous operation is completed, proceed to erase all pages */
FLASH->CR |= CR_MER_Set;
FLASH->CR |= CR_STRT_Set;

/* Wait for last operation to be completed */
status = FLASH_WaitForLastOperation(EraseTimeout);
if(status != FLASH_TIMEOUT)
{
/* if the erase operation is completed, disable the MER Bit */
FLASH->CR &= CR_MER_Reset;
}
}
/* Return the Erase Status */
return status;
}

/**
* @brief Erases the FLASH option bytes.
* @note This functions erases all option bytes and then deactivates the Read
* protection. If the user needs to keep the Read protection activated,
* he has to enable it after this function call (using
* FLASH_ReadOutProtection function)
* @param None
* @retval FLASH Status: The returned value can be: FLASH_ERROR_PG,
* FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT.
*/
FLASH_Status FLASH_EraseOptionBytes(void)
{
FLASH_Status status = FLASH_COMPLETE;

/* Wait for last operation to be completed */
status = FLASH_WaitForLastOperation(EraseTimeout);
if(status == FLASH_COMPLETE)
{
/* Authorize the small information block programming */
FLASH->OPTKEYR = FLASH_KEY1;
FLASH->OPTKEYR = FLASH_KEY2;

/* if the previous operation is completed, proceed to erase the option bytes */
FLASH->CR |= CR_OPTER_Set;
FLASH->CR |= CR_STRT_Set;
/* Wait for last operation to be completed */
status = FLASH_WaitForLastOperation(EraseTimeout);

if(status == FLASH_COMPLETE)
{
/* if the erase operation is completed, disable the OPTER Bit */
FLASH->CR &= CR_OPTER_Reset;

/* Enable the Option Bytes Programming operation */
FLASH->CR |= CR_OPTPG_Set;
/* Disable the Read protection */
OB->RDP= RDP_Key;
/* Wait for last operation to be completed */
status = FLASH_WaitForLastOperation(ProgramTimeout);

if(status != FLASH_TIMEOUT)
{
/* if the program operation is completed, disable the OPTPG Bit */
FLASH->CR &= CR_OPTPG_Reset;
}
}
else
{
if (status != FLASH_TIMEOUT)
{
/* Disable the OPTPG Bit */
FLASH->CR &= CR_OPTPG_Reset;
}
}
}
/* Return the erase status */
return status;
}

/**
* @brief Programs a word at a specified address.
* @param Address: specifies the address to be programmed.
* @param Data: specifies the data to be programmed.
* @retval FLASH Status: The returned value can be: FLASH_ERROR_PG,
* FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT.
*/
FLASH_Status FLASH_ProgramWord(uint32_t Address, uint32_t Data)
{
FLASH_Status status = FLASH_COMPLETE;
__IO uint32_t tmp = 0;

/* Check the parameters */
assert_param(IS_FLASH_ADDRESS(Address));
/* Wait for last operation to be completed */
status = FLASH_WaitForLastOperation(ProgramTimeout);

if(status == FLASH_COMPLETE)
{
/* if the previous operation is completed, proceed to program the new first
half word */
FLASH->CR |= CR_PG_Set;

*(__IO uint16_t*)Address = (uint16_t)Data;
/* Wait for last operation to be completed */
status = FLASH_WaitForLastOperation(ProgramTimeout);

if(status == FLASH_COMPLETE)
{
/* if the previous operation is completed, proceed to program the new second
half word */
tmp = Address + 2;

*(__IO uint16_t*) tmp = Data >> 16;

/* Wait for last operation to be completed */
status = FLASH_WaitForLastOperation(ProgramTimeout);

if(status != FLASH_TIMEOUT)
{
/* Disable the PG Bit */
FLASH->CR &= CR_PG_Reset;
}
}
else
{
if (status != FLASH_TIMEOUT)
{
/* Disable the PG Bit */
FLASH->CR &= CR_PG_Reset;
}
}
}
/* Return the Program Status */
return status;
}

/**
* @brief Programs a half word at a specified address.
* @param Address: specifies the address to be programmed.
* @param Data: specifies the data to be programmed.
* @retval FLASH Status: The returned value can be: FLASH_ERROR_PG,
* FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT.
*/
FLASH_Status FLASH_ProgramHalfWord(uint32_t Address, uint16_t Data)
{
FLASH_Status status = FLASH_COMPLETE;
/* Check the parameters */
assert_param(IS_FLASH_ADDRESS(Address));
/* Wait for last operation to be completed */
status = FLASH_WaitForLastOperation(ProgramTimeout);

if(status == FLASH_COMPLETE)
{
/* if the previous operation is completed, proceed to program the new data */
FLASH->CR |= CR_PG_Set;

*(__IO uint16_t*)Address = Data;
/* Wait for last operation to be completed */
status = FLASH_WaitForLastOperation(ProgramTimeout);
if(status != FLASH_TIMEOUT)
{
/* if the program operation is completed, disable the PG Bit */
FLASH->CR &= CR_PG_Reset;
}
}
/* Return the Program Status */
return status;
}

/**
* @brief Programs a half word at a specified Option Byte Data address.
* @param Address: specifies the address to be programmed.
* This parameter can be 0x1FFFF804 or 0x1FFFF806.
* @param Data: specifies the data to be programmed.
* @retval FLASH Status: The returned value can be: FLASH_ERROR_PG,
* FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT.
*/
FLASH_Status FLASH_ProgramOptionByteData(uint32_t Address, uint8_t Data)
{
FLASH_Status status = FLASH_COMPLETE;
/* Check the parameters */
assert_param(IS_OB_DATA_ADDRESS(Address));
status = FLASH_WaitForLastOperation(ProgramTimeout);
if(status == FLASH_COMPLETE)
{
/* Authorize the small information block programming */
FLASH->OPTKEYR = FLASH_KEY1;
FLASH->OPTKEYR = FLASH_KEY2;
/* Enables the Option Bytes Programming operation */
FLASH->CR |= CR_OPTPG_Set;
*(__IO uint16_t*)Address = Data;

/* Wait for last operation to be completed */
status = FLASH_WaitForLastOperation(ProgramTimeout);
if(status != FLASH_TIMEOUT)
{
/* if the program operation is completed, disable the OPTPG Bit */
FLASH->CR &= CR_OPTPG_Reset;
}
}
/* Return the Option Byte Data Program Status */
return status;
}

/**
* @brief Write protects the desired pages
* @param FLASH_Pages: specifies the address of the pages to be write protected.
* This parameter can be:
* @arg For @b STM32_Low-density_devices: value between FLASH_WRProt_Pages0to3 and FLASH_WRProt_Pages28to31
* @arg For @b STM32_Medium-density_devices: value between FLASH_WRProt_Pages0to3
* and FLASH_WRProt_Pages124to127
* @arg For @b STM32_High-density_devices: value between FLASH_WRProt_Pages0to1 and
* FLASH_WRProt_Pages60to61 or FLASH_WRProt_Pages62to255
* @arg For @b STM32_Connectivity_line_devices: value between FLASH_WRProt_Pages0to1 and
* FLASH_WRProt_Pages60to61 or FLASH_WRProt_Pages62to127
* @arg FLASH_WRProt_AllPages
* @retval FLASH Status: The returned value can be: FLASH_ERROR_PG,
* FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT.
*/
FLASH_Status FLASH_EnableWriteProtection(uint32_t FLASH_Pages)
{
uint16_t WRP0_Data 0xFFFF, WRP1_Data 0xFFFF, WRP2_Data = 0xFFFF, WRP3_Data = 0xFFFF;

FLASH_Status status = FLASH_COMPLETE;

/* Check the parameters */
assert_param(IS_FLASH_WRPROT_PAGE(FLASH_Pages));

FLASH_Pages = (uint32_t)(~FLASH_Pages);
WRP0_Data = (uint16_t)(FLASH_Pages & WRP0_Mask);
WRP1_Data = (uint16_t)((FLASH_Pages & WRP1_Mask) >> 8);
WRP2_Data = (uint16_t)((FLASH_Pages & WRP2_Mask) >> 16);
WRP3_Data = (uint16_t)((FLASH_Pages & WRP3_Mask) >> 24);

/* Wait for last operation to be completed */
status = FLASH_WaitForLastOperation(ProgramTimeout);

if(status == FLASH_COMPLETE)
{
/* Authorizes the small information block programming */
FLASH->OPTKEYR = FLASH_KEY1;
FLASH->OPTKEYR = FLASH_KEY2;
FLASH->CR |= CR_OPTPG_Set;
if(WRP0_Data != 0xFF)
{
OB->WRP0 = WRP0_Data;

/* Wait for last operation to be completed */
status = FLASH_WaitForLastOperation(ProgramTimeout);
}
if((status == FLASH_COMPLETE) && (WRP1_Data != 0xFF))
{
OB->WRP1 = WRP1_Data;

/* Wait for last operation to be completed */
status = FLASH_WaitForLastOperation(ProgramTimeout);
}
if((status == FLASH_COMPLETE) && (WRP2_Data != 0xFF))
{
OB->WRP2 = WRP2_Data;

/* Wait for last operation to be completed */
status = FLASH_WaitForLastOperation(ProgramTimeout);
}

if((status == FLASH_COMPLETE)&& (WRP3_Data != 0xFF))
{
OB->WRP3 = WRP3_Data;

/* Wait for last operation to be completed */
status = FLASH_WaitForLastOperation(ProgramTimeout);
}

if(status != FLASH_TIMEOUT)
{
/* if the program operation is completed, disable the OPTPG Bit */
FLASH->CR &= CR_OPTPG_Reset;
}
}
/* Return the write protection operation Status */
return status;
}

/**
* @brief Enables or disables the read out protection.
* @note If the user has already programmed the other option bytes before calling
* this function, he must re-program them since this function erases all option bytes.
* @param Newstate: new state of the ReadOut Protection.
* This parameter can be: ENABLE or DISABLE.
* @retval FLASH Status: The returned value can be: FLASH_ERROR_PG,
* FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT.
*/
FLASH_Status FLASH_ReadOutProtection(FunctionalState NewState)
{
FLASH_Status status = FLASH_COMPLETE;
/* Check the parameters */
assert_param(IS_FUNCTIONAL_STATE(NewState));
status = FLASH_WaitForLastOperation(EraseTimeout);
if(status == FLASH_COMPLETE)
{
/* Authorizes the small information block programming */
FLASH->OPTKEYR = FLASH_KEY1;
FLASH->OPTKEYR = FLASH_KEY2;
FLASH->CR |= CR_OPTER_Set;
FLASH->CR |= CR_STRT_Set;
/* Wait for last operation to be completed */
status = FLASH_WaitForLastOperation(EraseTimeout);
if(status == FLASH_COMPLETE)
{
/* if the erase operation is completed, disable the OPTER Bit */
FLASH->CR &= CR_OPTER_Reset;
/* Enable the Option Bytes Programming operation */
FLASH->CR |= CR_OPTPG_Set;
if(NewState != DISABLE)
{
OB->RDP = 0x00;
}
else
{
OB->RDP = RDP_Key;
}
/* Wait for last operation to be completed */
status = FLASH_WaitForLastOperation(EraseTimeout);

if(status != FLASH_TIMEOUT)
{
/* if the program operation is completed, disable the OPTPG Bit */
FLASH->CR &= CR_OPTPG_Reset;
}
}
else
{
if(status != FLASH_TIMEOUT)
{
/* Disable the OPTER Bit */
FLASH->CR &= CR_OPTER_Reset;
}
}
}
/* Return the protection operation Status */
return status;
}

/**
* @brief Programs the FLASH User Option Byte: IWDG_SW / RST_STOP / RST_STDBY.
* @param OB_IWDG: Selects the IWDG mode
* This parameter can be one of the following values:
* @arg OB_IWDG_SW: Software IWDG selected
* @arg OB_IWDG_HW: Hardware IWDG selected
* @param OB_STOP: Reset event when entering STOP mode.
* This parameter can be one of the following values:
* @arg OB_STOP_NoRST: No reset generated when entering in STOP
* @arg OB_STOP_RST: Reset generated when entering in STOP
* @param OB_STDBY: Reset event when entering Standby mode.
* This parameter can be one of the following values:
* @arg OB_STDBY_NoRST: No reset generated when entering in STANDBY
* @arg OB_STDBY_RST: Reset generated when entering in STANDBY
* @retval FLASH Status: The returned value can be: FLASH_ERROR_PG,
* FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT.
*/
FLASH_Status FLASH_UserOptionByteConfig(uint16_t OB_IWDG, uint16_t OB_STOP, uint16_t OB_STDBY)
{
FLASH_Status status = FLASH_COMPLETE;

/* Check the parameters */
assert_param(IS_OB_IWDG_SOURCE(OB_IWDG));
assert_param(IS_OB_STOP_SOURCE(OB_STOP));
assert_param(IS_OB_STDBY_SOURCE(OB_STDBY));

/* Authorize the small information block programming */
FLASH->OPTKEYR = FLASH_KEY1;
FLASH->OPTKEYR = FLASH_KEY2;

/* Wait for last operation to be completed */
status = FLASH_WaitForLastOperation(ProgramTimeout);

if(status == FLASH_COMPLETE)
{
/* Enable the Option Bytes Programming operation */
FLASH->CR |= CR_OPTPG_Set;

OB->USER = OB_IWDG | (uint16_t)(OB_STOP | (uint16_t)(OB_STDBY | ((uint16_t)0xF8)));

/* Wait for last operation to be completed */
status = FLASH_WaitForLastOperation(ProgramTimeout);
if(status != FLASH_TIMEOUT)
{
/* if the program operation is completed, disable the OPTPG Bit */
FLASH->CR &= CR_OPTPG_Reset;
}
}
/* Return the Option Byte program Status */
return status;
}

/**
* @brief Returns the FLASH User Option Bytes values.
* @param None
* @retval The FLASH User Option Bytes values:IWDG_SW(Bit0), RST_STOP(Bit1)
* and RST_STDBY(Bit2).
*/
uint32_t FLASH_GetUserOptionByte(void)
{
/* Return the User Option Byte */
return (uint32_t)(FLASH->OBR >> 2);
}

/**
* @brief Returns the FLASH Write Protection Option Bytes Register value.
* @param None
* @retval The FLASH Write Protection Option Bytes Register value
*/
uint32_t FLASH_GetWriteProtectionOptionByte(void)
{
/* Return the Falsh write protection Register value */
return (uint32_t)(FLASH->WRPR);
}

/**
* @brief Checks whether the FLASH Read Out Protection Status is set or not.
* @param None
* @retval FLASH ReadOut Protection Status(SET or RESET)
*/
FlagStatus FLASH_GetReadOutProtectionStatus(void)
{
FlagStatus readoutstatus = RESET;
if ((FLASH->OBR & RDPRT_Mask) != (uint32_t)RESET)
{
readoutstatus = SET;
}
else
{
readoutstatus = RESET;
}
return readoutstatus;
}

/**
* @brief Checks whether the FLASH Prefetch Buffer status is set or not.
* @param None
* @retval FLASH Prefetch Buffer Status (SET or RESET).
*/
FlagStatus FLASH_GetPrefetchBufferStatus(void)
{
FlagStatus bitstatus = RESET;

if ((FLASH->ACR & ACR_PRFTBS_Mask) != (uint32_t)RESET)
{
bitstatus = SET;
}
else
{
bitstatus = RESET;
}
/* Return the new state of FLASH Prefetch Buffer Status (SET or RESET) */
return bitstatus;
}

/**
* @brief Enables or disables the specified FLASH interrupts.
* @param FLASH_IT: specifies the FLASH interrupt sources to be enabled or disabled.
* This parameter can be any combination of the following values:
* @arg FLASH_IT_ERROR: FLASH Error Interrupt
* @arg FLASH_IT_EOP: FLASH end of operation Interrupt
* @param NewState: new state of the specified Flash interrupts.
* This parameter can be: ENABLE or DISABLE.
* @retval None
*/
void FLASH_ITConfig(uint16_t FLASH_IT, FunctionalState NewState)
{
/* Check the parameters */
assert_param(IS_FLASH_IT(FLASH_IT));
assert_param(IS_FUNCTIONAL_STATE(NewState));
if(NewState != DISABLE)
{
/* Enable the interrupt sources */
FLASH->CR |= FLASH_IT;
}
else
{
/* Disable the interrupt sources */
FLASH->CR &= ~(uint32_t)FLASH_IT;
}
}

/**
* @brief Checks whether the specified FLASH flag is set or not.
* @param FLASH_FLAG: specifies the FLASH flag to check.
* This parameter can be one of the following values:
* @arg FLASH_FLAG_BSY: FLASH Busy flag
* @arg FLASH_FLAG_PGERR: FLASH Program error flag
* @arg FLASH_FLAG_WRPRTERR: FLASH Write protected error flag
* @arg FLASH_FLAG_EOP: FLASH End of Operation flag
* @arg FLASH_FLAG_OPTERR: FLASH Option Byte error flag
* @retval The new state of FLASH_FLAG (SET or RESET).
*/
FlagStatus FLASH_GetFlagStatus(uint16_t FLASH_FLAG)
{
FlagStatus bitstatus = RESET;
/* Check the parameters */
assert_param(IS_FLASH_GET_FLAG(FLASH_FLAG)) ;
if(FLASH_FLAG == FLASH_FLAG_OPTERR)
{
if((FLASH->OBR & FLASH_FLAG_OPTERR) != (uint32_t)RESET)
{
bitstatus = SET;
}
else
{
bitstatus = RESET;
}
}
else
{
if((FLASH->SR & FLASH_FLAG) != (uint32_t)RESET)
{
bitstatus = SET;
}
else
{
bitstatus = RESET;
}
}
/* Return the new state of FLASH_FLAG (SET or RESET) */
return bitstatus;
}

/**
* @brief Clears the FLASH?s pending flags.
* @param FLASH_FLAG: specifies the FLASH flags to clear.
* This parameter can be any combination of the following values:
* @arg FLASH_FLAG_PGERR: FLASH Program error flag
* @arg FLASH_FLAG_WRPRTERR: FLASH Write protected error flag
* @arg FLASH_FLAG_EOP: FLASH End of Operation flag
* @retval None
*/
void FLASH_ClearFlag(uint16_t FLASH_FLAG)
{
/* Check the parameters */
assert_param(IS_FLASH_CLEAR_FLAG(FLASH_FLAG)) ;

/* Clear the flags */
FLASH->SR = FLASH_FLAG;
}

/**
* @brief Returns the FLASH Status.
* @param None
* @retval FLASH Status: The returned value can be: FLASH_BUSY, FLASH_ERROR_PG,
* FLASH_ERROR_WRP or FLASH_COMPLETE
*/
FLASH_Status FLASH_GetStatus(void)
{
FLASH_Status flashstatus = FLASH_COMPLETE;

if((FLASH->SR & FLASH_FLAG_BSY) == FLASH_FLAG_BSY)
{
flashstatus = FLASH_BUSY;
}
else
{
if((FLASH->SR & FLASH_FLAG_PGERR) != 0)
{
flashstatus = FLASH_ERROR_PG;
}
else
{
if((FLASH->SR & FLASH_FLAG_WRPRTERR) != 0 )
{
flashstatus = FLASH_ERROR_WRP;
}
else
{
flashstatus = FLASH_COMPLETE;
}
}
}
/* Return the Flash Status */
return flashstatus;
}

/**
* @brief Waits for a Flash operation to complete or a TIMEOUT to occur.
* @param Timeout: FLASH progamming Timeout
* @retval FLASH Status: The returned value can be: FLASH_ERROR_PG,
* FLASH_ERROR_WRP, FLASH_COMPLETE or FLASH_TIMEOUT.
*/
FLASH_Status FLASH_WaitForLastOperation(uint32_t Timeout)
{
FLASH_Status status = FLASH_COMPLETE;

/* Check for the Flash Status */
status = FLASH_GetStatus();
/* Wait for a Flash operation to complete or a TIMEOUT to occur */
while((status == FLASH_BUSY) && (Timeout != 0x00))
{
delay();
status = FLASH_GetStatus();
Timeout--;
}
if(Timeout == 0x00 )
{
status = FLASH_TIMEOUT;
}
/* Return the operation status */
return status;
}





Voilà dans l'ordre il y a buffer qui est sensé envoyer les données... en suite des fonctions pouvant servir à l'usb et enfin des fonction pour utiliser la mémoire flash
0

Discussions similaires

Recuperer les noms des fichiers ds un Dialogue
Nicolas___ -
Nicolas___ -

4 réponses
fermer boite de dialogue (j'ai déjà posé la question, mais impossible d'y arrive
cs_marsupio -
mavreick -

7 réponses
Ouvrir une boîte de dialogue
moongui -
Adeon -

2 réponses
Tiroir caisse sur imprimante USB
cs_Constantinople -
Celtiore -

4 réponses
Fermer une boite de dialoque Excel
geolap74 -
geolap74 -

3 réponses
Rejoignez-nous