Yahoo refuse tous les emails du site. Si vous avez une adresse chez un autre prestataire, c'est le moment de l'utiliser 
En cas de soucis, n'hésitez pas à aller faire un tour sur la page de contact en bas de page.
Topic "[STM32] Dialogue par USB depuis le PC"
Flux RSS des posts récents dans ce topic ( Flux Atom)
Bonjour tout le monde,
Je suis en train de travailler sur un processeur STM32F103RBT6 sur la carte OLIMEXINO-STM32 : https://www.olimex.com/Products/Duino/STM32/OLIMEXINO-STM32/.
Pour l'instant j'envoie et je reçois des trames CAN, mais j'aimerai pouvoir paramétrer un peu tout ça une fois que le code tourne sur mon microProcesseur (le tout sans recompiler et sans toucher au code). J'avais pensé en premier lieu à aller chercher les paramètres (nombre de trames à envoyer, ID et Data de chaque trame …) dans un fichier. Le soucis c'est que je ne trouve pas comment y accéder par USB (bien évidemment, si je donne le chemin d'accès à mon microP il ne retrouve pas le fichier, car ce dernier est sur le PC).
Concernant les contraintes matérielles, la meilleure solution reste l'USB (la carte doit être dans un boitier étanche, ça doit être facile d'utilisation, pas d'adaptateur à ajouter…). Malheureusement, les bibliothèques USB ne sont pas fournies avec l'IDE que j'utilise (CooCox CoIDE). J'ai beau éplucher la doc du STM32, impossible de savoir dans quel sens prendre tout ça afin de me faire une "librairie perso". Auriez-vous des conseils ou savez-vous où je peux trouver les librairies usb du stm32 ?
Je rajouterai qu'en branchant mon STM32 à mon PC via un cable usb, bah rien ne se passe (pas d'instal de driver, et il n'est pas reconnu par le PC).
Merci d'avance
Derniére modification le par Arkh3n
Salut Arkh3n,
Ne connaissant pas Coocox, je ne saurai trop t'aider, cependant je suis presque certain qu'il est possible d'utiliser les librairies en C de CubeHAL avec les docs "King Size" qui vont bien: UM1734 et UM1720
Qu'utilises-tu pour programmer ton µC? (JTAG, ST-LINK…)
En espérant que ça t'aide un peu.
Qu'utilises-tu pour programmer ton µC? (JTAG, ST-LINK…)
par weetoz
J'suis vraiment con… j'ai mal interprété la doc sur Olimex… Du coup je pensais qu'il fallait obligatoirement un programmeur hardware pour charger le programme.
Mais heuresement, il y a Skywodd qui fait bien le job.
Salut,
J'ai un peu avancé grâce à différentes réponses reçues sur d'autres forums, je vais donc laisser les nouveautés ici au cas où quelqu'un tombe dessus.
En premier lieu, pour te répondre weetoz, j'utilise un ST-LINK pour programmer la carte. En effet, mes encadrants ne voulaient pas entendre parler de maple, je n'ai pas donc pu utiliser l'alternative de l'USB pour programmer la flash comme décrit par Skywodd (j'avais vu quelques uns de ses messages sur un forum, d'où mon utilisation de CoIDe comme il l'utilise lui même).
Pour ce qui est de mon problème premier, on a décidé de passer par une communication en UART à l'aide d'un convertisseur UART-USB. De ce fait, on aura toujours une connectique USB sur la carte (facilité d'utilisation pour les clients), mais l'UART sera plus facile à utiliser pour moi pour coder la conversation entre le PC et la carte. Côté PC, je vais développer une application avec Windev pour envoyer mes octets de config sur ma carte.
Si vous avez des remarques ou questions, elles sont toujours les bienvenues !
Salut tout le monde,
J'up ce sujet parce qu'il me vient un problème lorsque j'essaye de coder mon UART … Pour tester, j'ai relié le Rx et Tx de l'USART2 de la carte (ports D0 et D1) et j'appelle le code suivant :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | int main(void)
{
//Configurations
Clk_Init();
//Boucle infinie
while(1)
{
InitUART(USART2);
USART_send_byte(USART2, 0xBA);
lecture = USART_read_byte(USART2);
}
}
|
Je voulais vérifier la valeur de lecture dans le débugger, sauf que je me retrouve dans une boucle infinie dans la fonction USART_read_byte (à cause du flag RXNE qui ne se met jamais à 1 (le RX n'est jamais prêt à être lu). Voici ce qui se trouve dans ces fonctions :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 | #include "includes.h"
void InitUART(USART_TypeDef* USARTx)
{
USART_ClockInitTypeDef Clock_USART2;
USART_InitTypeDef USART2_Definition;
/* VERIFIER QUE LES PARAMETRES PAR DEFAUT CORRESPONDENT AUX PARAMETRES REQUIS */
//UART GPIO Initialisation
GPIO_InitTypeDef GPIO_InitStructure;
/* GPIO clock enable */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIO_USART2, ENABLE);
/* Configure USART pin: RX */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_USART2_RX;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIO_USART2, &GPIO_InitStructure);
/* Configure USART pin: TX */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_USART2_TX;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIO_USART2, &GPIO_InitStructure);
GPIO_PinRemapConfig(GPIO_Remapping_USART2 , ENABLE);
/* USART Periph clock enable */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
//Activation UART
USART_Cmd(USARTx, ENABLE); // Je sélectionne l'UART "USART2" et je l'active.
//Definition Clock
USART_ClockStructInit(&Clock_USART2); //On initialise la structure "Clock" de l'UART avec les valeurs par défaut
USART_ClockInit(USARTx, &Clock_USART2); //On initialise la Clock grace aux paramètres définis dans la structure
//Definition Connection
USART_StructInit(&USART2_Definition); //On initialise la structure "USART2" avec ses valeurs par défaut
USART2_Definition.USART_BaudRate = 57600; //On change la valeur par défaut du Baudrate
USART_Init(USARTx, &USART2_Definition); //On initialise l'UART grace aux paramètres définis dans la structure
/* DEFINITION DES INTERRUPT A RAJOUTER SI BESOIN ! */
//USART2->CR1 |= 0x20; //Active l'interrupt de RXNE
}
void USART_send_byte(USART_TypeDef* USARTx, uint16_t Data)
{
while(USART_GetFlagStatus(USARTx, USART_FLAG_TXE)==0);
USART_SendData(USARTx, Data & 0x01FF);
}
uint16_t USART_read_byte(USART_TypeDef* USARTx)
{
while(USART_GetFlagStatus(USARTx, USART_FLAG_RXNE)==0);
return(USART_ReceiveData(USARTx));
}
|
Si vous avez des questions, n'hésitez pas … Parce que là je sèche … Je suis persuadé que c'est une connerie qui me manque, mais je m'arrache les cheveux sans trouver…
Merci d'avance !
PS : si il faut que je recréé un sujet, merci de me le dire !
Derniére modification le par Arkh3n
Salut Arkh3n,
Je ne connais pas l'API utilisée par Coocox, mais ce qui suit est pour moi l'attente d'une interruption:
1 | while(USART_GetFlagStatus(USARTx, USART_FLAG_RXNE)==0);
|
As-tu essayés d'activer l'interruption?
Weetoz.
Salut weetoz,
de ce que j'ai compris, ce n'est pas l'attente d'une interruption mais la consultation d'un flag
(le nom du flag et de l'interrupt sont pareils par contre). J'avais essayé d'activer l'interruption correspondante,
mais ça n'avait rien changé donc je l'ai commenté.
1 | //USART2->CR1 |= 0x20; //Active l'interrupt de RXNE
|
Mais peut être que je me plante …
Si ça peut aider, voilà l'usermanual :
http://www.st.com/content/ccc/resource/technical/document/reference_manual/59/b9/ba/7f/11/af/43/d5/CD00171190.pdf/files/CD00171190.pdf/jcr:content/translations/en.CD00171190.pdf
Derniére modification le par Arkh3n
Je viens de remarquer ça:
1 | GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
|
Je ne vois pas la configuration des "PullUps"…
1 | GPIO_InitStructure.GPIO_Pull = GPIO_PULLUP;
|
Du coup, comme l'API est un peu différente, je ne sais pas si "GPIO_PULLUP;" est correct, et si c'est nécessaire… (Pris en charge par l'API de Coocox…peut-être…).
De plus ça me semble un peu léger pour l'initialisation, voici ce que ça donne ( à titre d'xemple) avec STM32HAL: USART.c:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 | UART_HandleTypeDef huart3;
void MX_USART3_UART_Init(void)
{
huart3.Instance = USART3;
huart3.Init.BaudRate = 115200;
huart3.Init.WordLength = UART_WORDLENGTH_8B;
huart3.Init.StopBits = UART_STOPBITS_1;
huart3.Init.Parity = UART_PARITY_NONE;
huart3.Init.Mode = UART_MODE_TX_RX;
huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart3.Init.OverSampling = UART_OVERSAMPLING_16;
if (HAL_UART_Init(&huart3) != HAL_OK)
{
_Error_Handler(__FILE__, __LINE__);
}
}
void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
{
GPIO_InitTypeDef GPIO_InitStruct;
if(uartHandle->Instance==USART3)
{
/* USER CODE BEGIN USART3_MspInit 0 */
/* USER CODE END USART3_MspInit 0 */
/* USART3 clock enable */
__HAL_RCC_USART3_CLK_ENABLE();
/**USART3 GPIO Configuration
PB10 ------> USART3_TX
PB11 ------> USART3_RX
*/
GPIO_InitStruct.Pin = STLK_RX_Pin|STLK_TX_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF7_USART3;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
}
|
Bon oui, là c'est avec le DMA…
Peux-tu me poster cette fonction?
1 | InitUART(USART2);
|
Tout est peut-être là…
Si ça peut aider, voilà l'usermanual :
par Arkh3n
C'est hostile ça le matin!
Je viens de remarquer ça:
1 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; Je ne vois pas la configuration des "PullUps"…
1 GPIO_InitStructure.GPIO_Pull = GPIO_PULLUP;
C'est défini comme ça dans l'API :
1 2 3 4 5 6 7 8 9 10 11 | typedef struct
{
uint16_t GPIO_Pin; /*!< Specifies the GPIO pins to be configured.
This parameter can be any value of @ref GPIO_pins_define */
GPIOSpeed_TypeDef GPIO_Speed; /*!< Specifies the speed for the selected pins.
This parameter can be a value of @ref GPIOSpeed_TypeDef */
GPIOMode_TypeDef GPIO_Mode; /*!< Specifies the operating mode for the selected pins.
This parameter can be a value of @ref GPIOMode_TypeDef */
}GPIO_InitTypeDef;
|
avec les différents modes :
1 2 3 4 5 6 7 8 9 10 | typedef enum
{ GPIO_Mode_AIN = 0x0,
GPIO_Mode_IN_FLOATING = 0x04,
GPIO_Mode_IPD = 0x28,
GPIO_Mode_IPU = 0x48,
GPIO_Mode_Out_OD = 0x14,
GPIO_Mode_Out_PP = 0x10,
GPIO_Mode_AF_OD = 0x1C,
GPIO_Mode_AF_PP = 0x18
}GPIOMode_TypeDef;
|
donc j'avoue que j'ai utilisé le mode in floating parce que c'était le premier dans l'usermanual, mais les 2 sont possibles apparemment .. (page 166 de l'usermanual).
Pour l'initialisation, le USART typedef se retrouve initialisé dans la fonction
1 | USART_StructInit(&USART2_Definition);
|
1 2 3 4 5 6 7 8 9 10 | void USART_StructInit(USART_InitTypeDef* USART_InitStruct)
{
/* USART_InitStruct members default value */
USART_InitStruct->USART_BaudRate = 9600;
USART_InitStruct->USART_WordLength = USART_WordLength_8b;
USART_InitStruct->USART_StopBits = USART_StopBits_1;
USART_InitStruct->USART_Parity = USART_Parity_No ;
USART_InitStruct->USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
USART_InitStruct->USART_HardwareFlowControl = USART_HardwareFlowControl_None;
}
|
pour la fonction
1 | InitUART(USART2);
|
elle était déjà mise :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 | void InitUART(USART_TypeDef* USARTx)
{
USART_ClockInitTypeDef Clock_USART2;
USART_InitTypeDef USART2_Definition;
/* VERIFIER QUE LES PARAMETRES PAR DEFAUT CORRESPONDENT AUX PARAMETRES REQUIS */
//UART GPIO Initialisation
GPIO_InitTypeDef GPIO_InitStructure;
/* GPIO clock enable */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIO_USART2, ENABLE);
/* Configure USART pin: RX */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_USART2_RX;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIO_USART2, &GPIO_InitStructure);
/* Configure USART pin: TX */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_USART2_TX;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIO_USART2, &GPIO_InitStructure);
GPIO_PinRemapConfig(GPIO_Remapping_USART2 , ENABLE);
/* USART Periph clock enable */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
//Activation UART
USART_Cmd(USARTx, ENABLE); // Je sélectionne l'UART "USART2" et je l'active.
//Definition Clock
USART_ClockStructInit(&Clock_USART2); //On initialise la structure "Clock" de l'UART avec les valeurs par défaut
USART_ClockInit(USARTx, &Clock_USART2); //On initialise la Clock grace aux paramètres définis dans la structure
//Definition Connection
USART_StructInit(&USART2_Definition); //On initialise la structure "USART2" avec ses valeurs par défaut
USART2_Definition.USART_BaudRate = 57600; //On change la valeur par défaut du Baudrate
USART_Init(USARTx, &USART2_Definition); //On initialise l'UART grace aux paramètres définis dans la structure
/* DEFINITION DES INTERRUPT A RAJOUTER SI BESOIN ! */
//USART2->CR1 |= 0x20; //Active l'interrupt de RXNE
}
|
à moins que je n'ai pas compris un truc haha ..
C'est hostile ça le matin!
ouais j'avoue … Mais c'était pour que tu puisses trouver si t'avais des questions rapport au µP
en fait c'est celle-ci qui m'intéresse:
1 | USART_Cmd(USARTx, ENABLE);
|
Je pense que tu peux remplacer "GPIO_Mode_IN_FLOATING" par "GPIO_MODE_AF_PP", et voir si tu peux imposer les "PullUp".
( Pour moi le problème des "PullUps" est le plus évident).
Plus loin dans un post, tu as dis que tu avais posté tes questions dans un autre forum, un lien?
Je prend le train en marche
Pour l'USB, la configuration des périphériques, etc, etc. Te prends pas la tête, utilises Stm32CubeMX. C'est un utilitaire officiel de ST qui génère le code adéquat en fonction de ta configuration matérielle.
En bonus, ça génère un projet avec toutes les couches d'abstraction et fonctions qui vont bien pour te simplifier la vie.
Honnêtement, CooCox, c'est un projet qui commence à s’essouffler. Surtout que maintenant ST fourni un IDE complet gratuitement basé sur Eclipse (comme CoIDE). Certes c'est compatible STM32 uniquement mais si tu fais que du STM32, c'est largement suffisant et bien moins galère à mettre en oeuvre.
Salut Skywodd,
je pense la même chose.
Puis l'alternative "OnLine" MBed est aussi intéressante. Voir comment l'utiliser en "OffLine"…
J'ai voulu télécharger CoIde lorsque Arkh3n à ouvert ce topic, mais chez moi le site est inaccessible sans erreur 404 ou autre… Le but étant de découvrir l'API.
Alors, pour Weetoz :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | void USART_Cmd(USART_TypeDef* USARTx, FunctionalState NewState)
{
/* Check the parameters */
assert_param(IS_USART_ALL_PERIPH(USARTx));
assert_param(IS_FUNCTIONAL_STATE(NewState));
if (NewState != DISABLE)
{
/* Enable the selected USART by setting the UE bit in the CR1 register */
USARTx->CR1 |= CR1_UE_Set;
}
else
{
/* Disable the selected USART by clearing the UE bit in the CR1 register */
USARTx->CR1 &= CR1_UE_Reset;
}
}
|
Pour le coup des Pullup j'avoue ne pas avoir bien compris, comment je peux imposer le mode pullup si je donne comme mode AF PP ?
voici l'autre lien : http://forums.futura-sciences.com/electronique/817339-dialogue-entre-stm32-pc-via-usb-uart.html#post6126363
Pour Skywodd :
J'ai farfouillé un peu du côté de CubeMX (c'est d'ailleurs ici que j'ai trouvé les valeurs des ports pour configurer mes GPIO), le soucis c'est que je n'ai pas trouvé comment générer le code avec la même API que CooCox, donc quand il a fallu que je traduise des lignes de code pour que CooCox comprenne, bah j'ai un peu abandonné ^^.
Changer d'IDE ça risque de devoir me faire reprendre tout ce que j'ai fait, non ? 
mais bon, si c'est la seule solution je vais m'y tourner .. 
En fait il y a deux choses distincts: Le mode d'entrée/sortie:
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; qui dans ce cas signifie "Alternate Function Push Pull"
Le mode de tirage:
GPIO_InitStructure.GPIO_Pull = GPIO_PULLUP;
Tu trouveras dans le RM008 page 158 159… les explications détaillés.
Pour faire simple, une broche configurée en entrée doit être polarisé à un niveau logique stable.
Et pour ce faire on utilise des résistances de "tirages", d'où "PullUp" ou "PullDown".
Pour les sorties, bien que je ne sache pas ce qui diffère entre OpenDrain et PushPull, il est évident qu'il s'agit des technos de transistor que l'on veut choisir.
Comme je ne peux tester CoIde, je ne sais pas comment le faire (le tirage vers le haut).
Mais essaies la ligne que je t'ai mis, qui sait… Je crois comprendre ton amalgame, à la page 166 il est en effet stipulé ceci:
USARTx_RX ; Full duplex ;Input floating / Input pull-up
Il s'agit de deux paramètres différents. Le fait de dire au µC "Alternate Function Push Pull" ne lui fait pas comprendre que l'on veut également lui dire GPIO_InitStructure.GPIO_Pull = GPIO_PULLUP;
Donc en effet, la structure est incomplète:
1 2 3 4 5 6 7 8 9 10 11 | typedef struct
{
uint16_t GPIO_Pin; /*!< Specifies the GPIO pins to be configured.
This parameter can be any value of @ref GPIO_pins_define */
GPIOSpeed_TypeDef GPIO_Speed; /*!< Specifies the speed for the selected pins.
This parameter can be a value of @ref GPIOSpeed_TypeDef */
GPIOMode_TypeDef GPIO_Mode; /*!< Specifies the operating mode for the selected pins.
This parameter can be a value of @ref GPIOMode_TypeDef */
}GPIO_InitTypeDef;
|
Voici celle de l' API STMCubeHAL:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | typedef struct
{
uint32_t Pin; /*!< Specifies the GPIO pins to be configured.
This parameter can be any value of @ref GPIO_pins_define */
uint32_t Mode; /*!< Specifies the operating mode for the selected pins.
This parameter can be a value of @ref GPIO_mode_define */
uint32_t Pull; /*!< Specifies the Pull-up or Pull-Down activation for the selected pins.
This parameter can be a value of @ref GPIO_pull_define */
uint32_t Speed; /*!< Specifies the speed for the selected pins.
This parameter can be a value of @ref GPIO_speed_define */
uint32_t Alternate; /*!< Peripheral to be connected to the selected pins.
This parameter can be a value of @ref GPIO_Alternate_function_selection */
}GPIO_InitTypeDef;
|
Puis le groupe de def pour les valeurs de Pull:
1 2 3 4 5 6 7 | /** @defgroup GPIO_pull_define GPIO pull define
* @brief GPIO Pull-Up or Pull-Down Activation
* @{
*/
#define GPIO_NOPULL 0x00000000U /*!< No Pull-up or Pull-down activation */
#define GPIO_PULLUP 0x00000001U /*!< Pull-up activation */
#define GPIO_PULLDOWN 0x00000002U /*!< Pull-down activation */
|
Va peut-être falloir causer direct avec ces registre (p170 du Rm):
GPIOx_CRL, GPIOx_CRH…
Derniére modification le par weetoz
Bon … J'ai essayé pas mal de config différentes pour les PushPull en bidouillant les registres, j'ai essayé en Tx et Rx en connectant les 2 ports de ma carte et en regardant la valeur de Rx via le débugger. J'ai aussi fait comme décrit sur l'autre forum (ici) donc en testant juste le Tx, rien non plus …
Je commence à sécher haha, je pense que je vais tout raser et partir sur un truc propre comme dit par Skywodd, mais ça me fait bien rager de pas trouver la solution …
En fait ton µC ne permet pas la configuration des résistances et des transistors indépendamment l'une de l'autre.
Selon les µC les PullUp et PullDown ne sont pas forcément commune à l'entrée et à la sortie, et c'est le cas du F103RB alors que d'autres F469 eux peuvent avoir les PullUp et PullDown en entrée et sortie!
Donc pour toi:
1 | GPIO_InitStructure.GPIO_Mode = GPIO_PULLUP;
|
Voici la conf du 103 RB:
F103RB et celle du F469:
Derniére modification le par weetoz
Je commence à sécher haha, je pense que je vais tout raser et partir sur un truc propre comme dit par Skywodd, mais ça me fait bien rager de pas trouver la solution …
par Arkh3n
Je pense que ce serait mieux, CubeMX pour la conf, et SW4STM32 pour le programme.
Vu que tu as déjà Cubemix, ça devrait aller tout seule.
Selon les µC les PullUp et PullDown ne sont pas forcément commune à l'entrée et à la sortie, et c'est le cas du F103RB alors que d'autres F469 eux peuvent avoir les PullUp et PullDown en entrée et sortie!
Ouais, c'est pour ça que dans mon dernier essai j'ai setup mon output (le Tx) en Push Pull et l'input (Rx) en Pull Up, mais ça n'a rien changé ! 
Je pense que ce serait mieux, CubeMX pour la conf, et SW4STM32 pour le programme.
Vu que tu as déjà Cubemix, ça devrait aller tout seule.
J'ai aussi SW4STM32 vu que j'avais testé à l'époque où je cherchais un IDE … Je vais donc migrer dessus 
Bon, j'ai commencé à regarder SW4STM32 et j'avoue que ça fait un peu usine à gaz … Est-ce que vous auriez un tuto ou des conseils pour bien commencer ?
Par exemple, j'ai pas mal d'erreurs comme quoi NULL n'est pas reconnu … ça peut venir d'où ? Quelle librairie il faut inclure pour avoir la definition de NULL ?
Est-ce que vous auriez un tuto ou des conseils pour bien commencer ?
par Arkh3n
T'es sur LeCarnetDuMaker, il ya tout ce qu'il faut!! Tutoriels et cours, passe direct au vidéos.
Par exemple, j'ai pas mal d'erreurs comme quoi NULL n'est pas reconnu … ça peut venir d'où ? Quelle librairie il faut inclure pour avoir la definition de NULL ?
par Arkh3n
Alors quelques trucs:
Ne pas cocher "Generate Under Root" dans CubeMix
Mettre à jours (dans cet ordre): STM32Cube, Le firmware de ta carte (la lib), et SW4STM32
Dans SW4STM32, une fois le projet ouvert, clic droit sur le dossier-> index->Rebuild
Bon …
Premièrement merci Weetoz pour tes tutos bien fournis, je commence à me faire un peu la main sur SW4STM32 et CubeMX.
Par contre, il me vient un soucis (pour changer 
), quand je connecte ma carte via le ST-link, et que j'essaye de run, bah ça ne marche pas …
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | Open On-Chip Debugger 0.10.0-dev-00007-g58350bc-dirty (2018-01-12-12:21)
Licensed under GNU GPL v2
For bug reports, read
http://openocd.org/doc/doxygen/bugs.html
srst_only separate srst_nogate srst_open_drain connect_assert_srst
Info : The selected transport took over low-level target control. The results might differ compared to plain JTAG/SWD
adapter_nsrst_delay: 100
adapter speed: 950 kHz
Info : clock speed 950 kHz
Info : STLINK v2 JTAG v29 API v2 SWIM v7 VID 0x0483 PID 0x3748
Info : vid/pid are not identical: 0x0483/0x374B 0x0483/0x3748
Info : using stlink api v2
Info : Target voltage: 0.174346
Error: target voltage may be too low for reliable debugging
Error: init mode failed (unable to connect to the target)
in procedure 'program'
in procedure 'init' called at file "embedded:startup.tcl", line 485
in procedure 'ocd_bouncer'
** OpenOCD init failed **
shutdown command invoked
|
est-ce qu'il faut que je configure quelque part que je passe par SWD plutôt que par USB pour l'implémentation dans la RAM ? Parce que si oui j'ai pas trouvé …
Ce qui me fait un peu plus peur par contre, c'est que si j'essaye d'implémenter par CoIDE bah ça ne marche plus … Il me dit que la connexion ne se fait pas (j'ai beau checker les cables, les changer etc… rien n'y fait …) et comme une emmerde n'arrive jamais seule, ma carte se met à chauffer rapidement quand je l'alimente (9V, 1.33A, comme avant…) donc j'imagine que c'est assez lié et que quelque chose a cramé (pourquoi ? Je ne sais pas …..) mais j'aimerai votre avis avant ..
Derniére modification le par Arkh3n
As-tu le soft STM32 ST-Link Utility? (STSW-LINK004 "get software" en bas de la page)
D'après Open OCD, ton "vid/PID" n'est pas identique 0x0483/0x374B 0x0483/0x3748.
Met à jour le driver de ton ST-Link (selon sa version) via ST-Link Utility, et depuis ce dernier essais de charger le binaire qui à normalement été créé par OpenOCD.
Je pense qu'il te faut aussi rentrer plus dans la doc d'Olimex, tu devrais pouvoir y trouver les informations pour configurer les connectiques de ta carte selon la façon dont ont charge un programme.
Malheureusement, je ne possède pas cette carte, et je n'ai donc pas rencontré ce problème de chauffe excessive. Voir aussi comment tu configure ton projet depuis CubeMix…
Schéma Olimexduinostm32
IMPORTANT! In this revision there are changes to the POWER connector of the Arduino shield. Now there are 5V avalable at pin #3 of the POWER connector by default! It was 3.3V in older revisions. Be careful if you use 3.3V shields! You can revert the voltage of the pin back to 3.3V if you change the position of the 3V3A/5V jumper!
Peux-tu détailler plus ton projet?
j'ai essayé ST-Link Utility et ça ne marche pas mieux .. J'ai des messages d'erreurs : usb not connected alors qu'ile est pourtant bien reconnu par l'ordi .. (j'ai mis à jour le driver avant rien ne change).
Le soucis avec la doc d'Olimex c'est qu'elle est très succinte et ya pas grand chose qui m'aide dedans (ou alors je n'arrive pas à comprendre).
J'ai réussi à isoler quels composants crééent de la chaleur : la Diode D5 entre l'USB et le +5V et les deux MOS VR1 et VR2 dans le power supply (page 5 de la doc : ici)
Peux-tu détailler plus ton projet?
- En premier lieu je dois pouvoir envoyer et recevoir des trames CAN dans un réseau CAN - Ensuite je dois trouver un moyen de configurer ces trames CAN (nombre de trames, ID, message …) sans avoir à changer mon code et recompiler (d'où le début de mon topic, utilisation de l'UART, USB …) - Enfin, si j'ai le temps, arriver à contrôler les ADC du µC.
Le seul jumper que j'ai changé est celui de la terminaison CAN (120 Ohm).
Ce qui m'intrigue vraiment c'est que j'ai déjà fait des essais sur la carte pour envoyer des trames CAN (et j'y arrivais), donc j'ai déjà utilisé cette carte, elle ne chauffait pas et l'implémentation se faisait sans soucis. Mais depuis hier rien ne marche …