STM32F446 - Problem mit Interrupt

[Wühlhase (Gast)]

Hallo

Ich möchte auf einem Nucleoboard mit einem STM32F446RE einen Interrupt 
generieren, hab damit allerdings anscheinend ein grundsätzliches 
Problem.

Ich hab (neben einigen anderen Tutorials) das hier ausprobiert:
https://www.youtube.com/watch?v=G7u5vYJhwuM

Allerdings tut sich da absolut nix. Ich möchte zum Test mit dem Taster 
über einen Interrupt die LED toggeln, allerdings passiert nichts. Wenn 
ich den STM32 im Debug-Modus laufen lasse, springt er sofort an die 
markierte Stelle (siehe Bild).

Ich sitz jetzt schon mehrere Wochen an dem Problem und komm einfach 
nicht weiter. Hat jemand eine Idee? Das Projekt ist im Anhang, zuviele 
Code um das hier reinzustellen.

Ich benutze das Embedded Studio von Segger (das Projekt selber sollte 
aber Keil-kompatibel sein, wurde mit CubeMX generiert), den STLink hab 
ich zu einem JLink umgeflasht.

[pegel (Gast)]

Ich kenne Segger und Keil nicht, aber wieso benutzt deine IDE eine 
allgemeine Cortex_M_Startup.s die nur einen Teil der Interrupts des F446 
bedient?

Die richtige wäre:
startup_stm32f446xx.s

Kann es sein, dass du nur ein allgemeines Projekt erstellt hast, und 
keins speziell für das Board bzw. den µC?

[Patrick S. (pad)]

Moin,

ist das Projekt mit CubeMX erzeugt?

Ohne die HAL nun auswendig zu kennen...du übergibst zwar das GPIO_PIN_13 
deine Interruptquelle sein soll...aber was dann passieren soll...z.B. 
HAL_GPIO_write_pin(...) oder so ähnlich, kann ich nicht entdecken.

Ich hab Interrupts letztes mal direkt auf Registern programmiert...aber 
wo wird den konfiguriert wann ein Interrupt ausgelößt werden soll? 
(RisingEdge, FallingEdge, etc.)

Gruß

[Wühlhase (Gast)]

Hallo

Ja, das Projekt wurde mit CubeMX erzeugt.

Vielen Dank für den Hinweis mit der Cortex_startup-wie gesagt, 
generiertes Projekt. Das probiere ich mal aus.

Ich hab mich bei diesem Projekt an oben verlinktes Video 
entlanggehangenlt. Da hat er in der main.c irgendwo unten eine Funktion 
eingefügt, HAL_EXTI_Callback oder so ähnlich. Die hab ich auch eingefügt 
und in ihr die Funktion HAL_GPIO_TogglePin() aufgerufen.

Ich hab in vorherigen Versuchen auch die Variante mit der (generierten) 
Funktion EXTI15_10_IRQHandler() ausprobiert-mit dem bekannten Ergebnis.

[pegel (Gast)]

Ist so weit richtig mit der Callback Funktion.
Die ist in der stm32f4xx_hal_gpio.c als weak festgelegt.

Problematisch könnte das Tastenprellen sein, wer weiss wie oft die LED 
Toggelt.
Das würde ich anders regeln.

[pegel (Gast)]

Ist das bei Segger auch so schön geregelt das man die Funktionen 
verfolgen kann?
Bei SW4STM32 kann ich mit F3 in die Funktionen abtauchen und sehen was 
genau passiert.

[Wühlhase (Gast)]

Was meinst du mit "abtauchen"?

Ich kann mir an beliebiger Stelle einen Haltepunkt setzen, und das 
Progamm hält erstmal an wenn es diesen passiert, kann Variablen 
auslesen, usw.

Ich werde jetzt die startupdatei austauschen und sehen was 
passiert...ich melde mich wieder.

[pegel (Gast)]

Wühlhase schrieb:
> Was meinst du mit "abtauchen"?

Die Funktionen verfolgen und sehen was genau darin passiert.
Das Ganze geht bis auf die Register Ebene.

[Wühlhase (Gast)]

Also wie gesagt-Haltepunkt ansetzen und registergucken geht.

Ich hab die cortex_m_startup mal vom Build ausgeschlossen und dafür die 
die startup_f446xx eingebaut.

Nun krieg ich 520 Kompoilierfehler, sowas wie "Junk at end of line" (der 
scheint sich an den Assembler-Kommentaren wie ;*** Kommentar *** zu 
stören), oder bad instruction "irgendein ASM-Befehl"

Was soll ich davon halten?

[pegel (Gast)]

Das asm Format ist das Falsche.
Ich würde sagen es ist immer noch ein grundsätzliches Projekt Problem.

[Patrick S. (pad)]

Moin,

da ist doch irgendwas faul mit deinem Projekt. Das sollte eigentlich 
problemlos lauffähig sein wenn das aus CubeMX rausfällt.

Gruß

[Christopher J. (christopher_j23)]

pegel schrieb:
> Ich würde sagen es ist immer noch ein grundsätzliches Projekt Problem.

Ich würde sagen es ist vor allem ein Verständnisproblem.

Patrick S. schrieb:
> Das sollte eigentlich problemlos lauffähig sein wenn das aus CubeMX
> rausfällt.

Wenn er das als Keilprojekt aus CubeMX generiert, dann packt CubeMX eben 
auch den für Keil passenden Startup-Code mit rein und der wiederum 
schmeckt dem Gnu-Assembler nicht.

Warum es mit dem Startup-Code von Segger nicht klappt kann verschiedene 
Gründe haben. Dafür müsste der TO aber mal Butter bei die Fische geben 
und seinen Source-Code herzeigen.

[Wühlhase (Gast)]

Christopher J. schrieb:
> Warum es mit dem Startup-Code von Segger nicht klappt kann verschiedene
> Gründe haben. Dafür müsste der TO aber mal Butter bei die Fische geben
> und seinen Source-Code herzeigen.

Das Projekt ist oben in der .zip drin. :)
Ansonsten hab ich den Code aus der main auch nochmal reingestellt.

Ich hab mir aus Verzweiflung heute Nachmittag SW4STM32 installiert. Mal 
eine Frage an die, die das nutzen: Wo kann man die Autovervollständigung 
aktivieren? Sobald ich anfange, in Embedded Studio HAL einzutippen zeigt 
er mir u.a. sämtliche Hal-Funktionen an, auch Konstanten wie z.B. die 
Port- oder Pinbezeichnungen. Sowas hat Eclipse doch sicherlich auch...

Code:

/**
  ******************************************************************************
  * File Name          : main.c
  * Description        : Main program body
  ******************************************************************************
  ** This notice applies to any and all portions of this file
  * that are not between comment pairs USER CODE BEGIN and
  * USER CODE END. Other portions of this file, whether 
  * inserted by the user or by software development tools
  * are owned by their respective copyright owners.
  *
  * COPYRIGHT(c) 2017 STMicroelectronics
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
  *   1. Redistributions of source code must retain the above copyright notice,
  *      this list of conditions and the following disclaimer.
  *   2. Redistributions in binary form must reproduce the above copyright notice,
  *      this list of conditions and the following disclaimer in the documentation
  *      and/or other materials provided with the distribution.
  *   3. Neither the name of STMicroelectronics nor the names of its contributors
  *      may be used to endorse or promote products derived from this software
  *      without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  ******************************************************************************
  */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "stm32f4xx_hal.h"

/* USER CODE BEGIN Includes */

/* USER CODE END Includes */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */
/* Private variables ---------------------------------------------------------*/

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_NVIC_Init(void);

/* USER CODE BEGIN PFP */
/* Private function prototypes -----------------------------------------------*/

/* USER CODE END PFP */

/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

int main(void)
{

  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration----------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();

  /* Initialize interrupts */
  MX_NVIC_Init();

  /* USER CODE BEGIN 2 */
  
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
  /* USER CODE END WHILE */

  /* USER CODE BEGIN 3 */

  }
  /* USER CODE END 3 */

}

/** System Clock Configuration
*/
void SystemClock_Config(void)
{

  RCC_OscInitTypeDef RCC_OscInitStruct;
  RCC_ClkInitTypeDef RCC_ClkInitStruct;

    /**Configure the main internal regulator output voltage 
    */
  __HAL_RCC_PWR_CLK_ENABLE();

  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE3);

    /**Initializes the CPU, AHB and APB busses clocks 
    */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = 16;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
  RCC_OscInitStruct.PLL.PLLM = 16;
  RCC_OscInitStruct.PLL.PLLN = 336;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV4;
  RCC_OscInitStruct.PLL.PLLQ = 2;
  RCC_OscInitStruct.PLL.PLLR = 2;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

    /**Initializes the CPU, AHB and APB busses clocks 
    */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

    /**Configure the Systick interrupt time 
    */
  HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/1000);

    /**Configure the Systick 
    */
  HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);

  /* SysTick_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);
}

/** NVIC Configuration
*/
static void MX_NVIC_Init(void)
{
  /* RCC_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(RCC_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(RCC_IRQn);
  /* EXTI15_10_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(EXTI15_10_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(EXTI15_10_IRQn);
}

/** Configure pins as 
        * Analog 
        * Input 
        * Output
        * EVENT_OUT
        * EXTI
     PA2   ------> USART2_TX
     PA3   ------> USART2_RX
*/
static void MX_GPIO_Init(void)
{

  GPIO_InitTypeDef GPIO_InitStruct;

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOH_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(LD2_GPIO_Port, LD2_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pin : PC13 */
  GPIO_InitStruct.Pin = GPIO_PIN_13;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

  /*Configure GPIO pins : USART_TX_Pin USART_RX_Pin */
  GPIO_InitStruct.Pin = USART_TX_Pin|USART_RX_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.Alternate = GPIO_AF7_USART2;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /*Configure GPIO pin : LD2_Pin */
  GPIO_InitStruct.Pin = LD2_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(LD2_GPIO_Port, &GPIO_InitStruct);

}

/* USER CODE BEGIN 4 */
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin){
  HAL_GPIO_TogglePin(LD2_GPIO_Port, LD2_Pin);
}
/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @param  None
  * @retval None
  */
void _Error_Handler(char * file, int line)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  while(1) 
  {
  }
  /* USER CODE END Error_Handler_Debug */ 
}

#ifdef USE_FULL_ASSERT

/**
   * @brief Reports the name of the source file and the source line number
   * where the assert_param error has occurred.
   * @param file: pointer to the source file name
   * @param line: assert_param error line source number
   * @retval None
   */
void assert_failed(uint8_t* file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
    ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */

}

#endif

/**
  * @}
  */ 

/**
  * @}
*/ 

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

[Christopher J. (christopher_j23)]

Sry, war blind. Die für den GCC passende Startup-Datei findest du in 
deinem Projektverzeichnis in 
Drivers/CMSIS/Device/ST/Source/Templates/GCC. Die andere 
"startup_stm32f446xx.s" ist wie schon vermutet für den Keil Assembler. 
Der  Startup-Code alleine wird dir aber nichts bringen, weil du auch 
noch ein dazu passendes Linkerscript brauchst und das "TestInterrupt.ld" 
im Obj-Verzeichnis passt nicht zu dem Startup-Code von ST.

Am einfachsten ist wohl SW4STM32 zu verwenden. Wenn du unabhängig von 
irgendeiner IDE bleiben willst, dann kannst du dir von CubeMX auch ein 
Makefile-Projekt erstellen lassen. Das sollte dann überall laufen, egal 
ob mit Eclipse, emIDE oder was weiß ich.

Autovervollständigung geht bei Eclipse standardmäßig mit Strg+Leertaste 
oder bei Structs bzw. Klassen auch von alleine, sobald du '.' bzw. '->' 
eintippst.

[Wühlhase (Gast)]

Das scheint mir zwar schlüssig was du da schreibst-allerdings hätte ich 
erwartet dass das Embedded Studio das zurechtkonvertiert. Immerhin hat 
das Embedded Studio eine Import-Funktion für Keil-Projekte.
Und so banale Dinge wie Pins setzen/auslesen, UART-Eingangsregister 
auslesen, PWM, usw. hab ich damit schon hinbekommen.

Andererseits-an Interrupts hab ich mir bisher immer die Zähne 
ausgebissen...

Ich werds jetzt mal mit dem AC6-Dingens versuchen.

Auch wenn ich mich ganz sicher nochmal mit Fragen zurückmelden werde, 
habt vielen Dank für die Hilfe bisher. :)

[Wühlhase (Gast)]

Ich kanns nicht glauben...jetzt funktioniert es...wie bin ich froh, 
vielen dank nochmal. :)

Und die nächste Frage: die Funktion void HAL_GPIO_EXTI_Callback(uint16_t 
GPIO_Pin), wo finde ich diese Deklaration standardmäßig z.B. für 
Timer-Interrupts, ADC- oder UART-Interrupts?

[Til S. (Firma: SEGGER) (til_s)]

Wühlhase schrieb:
> Das scheint mir zwar schlüssig was du da schreibst-allerdings hätte ich
> erwartet dass das Embedded Studio das zurechtkonvertiert. Immerhin hat
> das Embedded Studio eine Import-Funktion für Keil-Projekte.

Du kannst zwar in unserem Embedded Studio Keil und IAR Projekte 
importieren aber Embedded Studio kann natürlich nicht deine Applikation 
abändern. D.h. wenn du Keil spezifische Intrinsics oder Assembler 
benutzt musst du diese leider selber von Hand abändern.

Dein Problem zeigt auch den Nachteil von solchen STM32Cube Geschichten. 
Wenn etwas nicht funktioniert wird es erstmal schwer. Die Alternative 
wäre ein Projekt für dein Device von Embedded Studio generieren lassen 
und dann den Code für die Initialisierung des Interrupts selber zu 
schreiben. Man muss sich zwar mit dem Device auseinander setzen aber 
dafür weiß man auch, was man tut.

[Wühlhase (Gast)]

Til S. schrieb:
> Dein Problem zeigt auch den Nachteil von solchen STM32Cube Geschichten.
> Wenn etwas nicht funktioniert wird es erstmal schwer. Die Alternative
> wäre ein Projekt für dein Device von Embedded Studio generieren lassen
> und dann den Code für die Initialisierung des Interrupts selber zu
> schreiben. Man muss sich zwar mit dem Device auseinander setzen aber
> dafür weiß man auch, was man tut.

Das ist völlig richtig, und da will ich auch mal hin. Meine ersten 
Versuche waren auch, in einem ES-Projekt gleich die notwendigen Register 
selber zu setzen (die Arbeitsweise kenne ich ja von den AVRs). Der 
Überwurf, den die HAL mit sich bringt, gefällt mir nicht.

Soweit ich nur Pins setzen wollte hat das auch wunderbar funktioniert 
(nachdem ich festgestellt hab das ein Port erst mit Takt versorgt sein 
will bevor er was tut). Für die SPI hat das schon nicht mehr gereicht, 
die hab ich über Register wochenlang nicht zum Laufen gebracht, während 
es Cube mir da deutlich einfacher gemacht hat. (Den Code hat ES auch 
klaglos verarbeitet...)

[Til S. (Firma: SEGGER) (til_s)]

Was man immer gut machen kann ist auf der einen Seite mit einem eigenen 
sauberen Projekt anfangen und sich auch der anderen Seite ein Projekt 
von STM32Cube bzw. ähnlichen Tools generieren zu lassen. Dann kann man 
in dem generierten Projekt abschauen, wie eine bestimmte Peripherie 
initialisiert werden muss und kann einzelnen Codeteile daraus benutzen.

Was du natürlich auch gerne machen kannst ist unser embOS zu 
missbrauchen. Du kannst eine embOS Trial Version für Cortex-M und 
Embedded Studio von unserer Webseite downloaden und findest in dem Zip 
File schon fertige Board Support Packages für viele Evalboards. In den 
embOS BSPs wird zwar keine Hardware wie z.B. SPI initialisiert aber man 
hat zum einem ein sauberes Projekt, was out of the box läuft, und zum 
anderen direkt schon ein RTOS mit drin. Das muss man dann natürlich 
nicht benutzen aber ist nice to have.

[Wühlhase (Gast)]

Vielen Dank nochmal...der STM32 macht mir jetzt richtig Spaß. :)
Zwar mit HAL und Cube...aber das Ding macht immerhin endlich was es 
soll.

@Til:
Danke für den Tip mit dem emOS, ich muß dazu allerdings sagen daß ich 
damit nicht viel anfangen kann (bin E-Techniker, Programmierung ist bei 
mir eher nur Werkzeug-obgleich ich versuche, stetig besser zu werden und 
meinen Horizont gern erweitere).
Einmal weil es eben nicht frei ist-der Einarbeitungsaufwand ist mir 
einfach zu hoch dafür, daß ich es eben nur eine begrenzte Zeit testen 
kann.

Dennoch würde ich gern wissen, welche Funktion emOS hat. Wenn man die 
Peripherie noch selber initialisieren muß-was macht es dann? Bei 
"großen" Betriebssstemen wie Linux hab ich zumindest eine Vorstellung 
von dem was die machen-da kommt man an die Hardware selber dafür aber 
kaum noch ran um z.B. Pins zu toggeln.

Und zum Zweiten:
Wie ich oben schon schrob hab ich meine ersten Geh-Versuche mit dem 
STM32 auf Registerebene gemacht-und da will ich auch wieder hin, die HAL 
bringt leider wirklich viel Ballast mit sich und die ersten 
Einschränkungen hab ich damit auch schon erfahren. Allerdings hab ich 
mit Registerschubserei bisher nur Pins setzen/auslesen können (und das 
war schon ein echter Krampf bis ich erfahren hab daß ich die z.B. erst 
am Bustakt aktivieren muß-das z.B. steht nicht im entsprechenden Kapitel 
in der Refferenz). PWM, SPI u.ä. hab ich so gar nicht erst zum Laufen 
bekommen.

Hat jemand ein Programm, wo ein Interrupt aktiv ist, das ohne Bibliothek 
auskommt (also HAL oder Standardlib, eben die normalen 
Registerbezeichnungen) und das auch funktioniert? Ich würde das mal 
gerne mit meinen füheren Versuchen vergleichen und sehen, was ich da 
vergessen haben könnte einzustellen.

[pegel (Gast)]

Nicht für den F4, aber "ganz normale Registerbezeichnungen" gibt es 
hier:
http://en.radzio.dxp.pl/stm32vldiscovery/

[Til S. (Firma: SEGGER) (til_s)]

Wühlhase schrieb:
> @Til:
> Danke für den Tip mit dem emOS, ich muß dazu allerdings sagen daß ich
> damit nicht viel anfangen kann (bin E-Techniker, Programmierung ist bei
> mir eher nur Werkzeug-obgleich ich versuche, stetig besser zu werden und
> meinen Horizont gern erweitere).
> Einmal weil es eben nicht frei ist-der Einarbeitungsaufwand ist mir
> einfach zu hoch dafür, daß ich es eben nur eine begrenzte Zeit testen
> kann. Dennoch würde ich gern wissen, welche Funktion emOS hat. Wenn man
> die Peripherie noch selber initialisieren muß-was macht es dann?

embOS ist ein Real Time Operating System für Mikrocontroller und 
Mikroprozessoren, also für alles vom 8051 bis hin zu deiner Handy 
Hardware (Multicore ARM Cortex-A, usw.).
Ganz einfach ausgedrückt hilft dir ein RTOS dabei mehrere Teile deiner 
Applikation quasi parallel laufen zu lassen. Stell dir vor du müsstest 
einen MP3 Player bauen, der gleichzeitig das Lied abspielen, das Display 
aktualisieren und über USB kommunizieren müsste. Wenn du das ohne RTOS 
programmierst wird es sehr schwer. Mit RTOS würdest du für jede Aufgabe 
einfach jeweils eine Task anlegen. Das RTOS kümmert sich dann darum das 
alle Tasks zu rechten Zeit ausgeführt werden und z.B. das Lied nicht 
ruckelt. Das wesentliche bei RTOS ist der Begriff "Real Time". Das 
klassische Beispiel ist eine Industriesteuerung mit einem 
Notausschalter. Ein RTOS garantiert dir eine Antwortzeit, in der die 
Task, welche die Maschine abschaltet, nach Bestätigen des 
Notausschalters ausgeführt wird. Das hat man bei Linux oder Windows 
nicht.
embOS bietet einen gewissen Grad an Hardware Abstraktion aber im 
Unterschied zu Linux brauchst du hier keine Device Treiber. D.h. du 
kannst aus den Tasks heraus immer noch auf alle Hardware zugreifen.

Im Prinzip hatte ich dir die embOS BSPS aber auch nur empfohlen, weil 
die Projekte so schön out of the box funktionieren, d.h. du müsstest 
dich nicht mehr um Startup Code, Linker Files, Clock Initialisierung 
usw. kümmern.

Richtig, embOS ist ein kommerzielles Produkt aber die Trial Version ist 
auf unserer Webseite frei verfügbar. Wir unterstützen ja bereits 
Hobbyisten mit z.B. Embedded Studio. Ähnliches könnten wir auch mit 
embOS machen.

[Wühlhase (Gast)]

Danke für die Erläuterungen...ja, das klingt sinnvoll. Genau dafür hatte 
ich den Timer oben geplant, und alles andere (z.B. Kommunikation, ADC) 
wollte ich mit Interrupts erschlagen. Was in der Tat unangenehm ausarten 
kann...

Til S. schrieb:
> Richtig, embOS ist ein kommerzielles Produkt aber die Trial Version ist
> auf unserer Webseite frei verfügbar. Wir unterstützen ja bereits
> Hobbyisten mit z.B. Embedded Studio. Ähnliches könnten wir auch mit
> embOS machen.
Das wäre prima. :)

@pegel:
Vielen Dank...das ist genau das was ich suche. Jetzt bin ich ja mal 
gespannt warum das damals nicht geklappt hat...

[Til S. (Firma: SEGGER) (til_s)]

Wühlhase schrieb:
> Til S. schrieb:
>> Richtig, embOS ist ein kommerzielles Produkt aber die Trial Version ist
>> auf unserer Webseite frei verfügbar. Wir unterstützen ja bereits
>> Hobbyisten mit z.B. Embedded Studio. Ähnliches könnten wir auch mit
>> embOS machen.
> Das wäre prima. :)

Ist die Trial Limitierung für euch Hobbyisten eigentlich ein Problem? Im 
Moment ist es so, dass embOS nach 12 Stunden den Betrieb einstellt, wenn 
mehr als drei Tasks gestartet werden. Das ist für eine Evaluierung kein 
Problem aber ich kann mir vorstellen, dass dies für manche Projekte 
unpraktisch ist.

[pegel (Gast)]

Ich denke es ist immer ein Problem wenn man sich in etwas einarbeitet 
das  vielleicht so gut funktioniert das man sein Projekt dann schöner 
und besser machen will.
Dann kommt der Zeitpunkt X und das große "DENKSTE"!

Muss ich nicht haben.

[Til S. (Firma: SEGGER) (til_s)]

pegel schrieb:
> Dann kommt der Zeitpunkt X und das große "DENKSTE"!

Was meinst du mit Zeitpunkt X?
Was sind genau deine Bedenken?

[Christopher J. (christopher_j23)]

Til S. schrieb:
> Was meinst du mit Zeitpunkt X?

Ich denke mal er meint den Zeitpunkt an dem man z.B. mehr als drei Tasks 
haben möchte oder wie auch immer an die (künstlichen) Limitierungen 
stößt.

Wenn ihr wollt, das euer EmbOS wirkliche Verbreitung findet, dann 
solltet ihr vielleicht darüber nachdenken es einfach dual zu 
lizensieren, d.h. GPLv3 und kommerziell. Vielleicht erscheint euch das 
zu riskant und ihr habt Angst, es könnte jemand gegen die GPL verstoßen 
oder wie auch immer aber ich glaube, das es unterm Strich sogar dafür 
sorgt, dass ihr mehr kommerzielle Lizenzen verkaufen würdet.

Denkt mal z.B. an den Dozent an der Uni oder einen Berufsschullehrer. 
Warum genau sollten die ihren Schützlingen euer OS nahelegen? Es ist ja 
auch nicht so, dass es keine Alternativen gäbe. FreeRTOS und ChibiOS 
gibt es unter der GPL und ersteres sogar mit "static linking exception". 
RTX oder Nuttx gibt es unter Apache- bzw. BSD-Lizenz komplett zur freien 
Verfügung.

[Til S. (Firma: SEGGER) (til_s)]

Danke Christoper für dein Feedback!

Christopher J. schrieb:
> Ich denke mal er meint den Zeitpunkt an dem man z.B. mehr als drei Tasks
> haben möchte oder wie auch immer an die (künstlichen) Limitierungen
> stößt.

Ok, danke, aber das war ja gerade die Überlegung, diese Limitierung zu 
entfernen.

Christopher J. schrieb:
> Wenn ihr wollt, das euer EmbOS wirkliche Verbreitung findet, dann
> solltet ihr vielleicht darüber nachdenken es einfach dual zu
> lizensieren, d.h. GPLv3 und kommerziell. Vielleicht erscheint euch das
> zu riskant und ihr habt Angst, es könnte jemand gegen die GPL verstoßen
> oder wie auch immer aber ich glaube, das es unterm Strich sogar dafür
> sorgt, dass ihr mehr kommerzielle Lizenzen verkaufen würdet.

Ich muss ganz ehrlich gestehen, dass ich mich mit GPL nicht gut auskenne 
aber ich denke eigentlich, dass unsere Lizenzbedingungen dann 
ausreichend wären. Aber man kann sich ja auch mal in der Richtung 
Gedanken machen.

Christopher J. schrieb:
> Denkt mal z.B. an den Dozent an der Uni oder einen Berufsschullehrer.
> Warum genau sollten die ihren Schützlingen euer OS nahelegen? Es ist ja
> auch nicht so, dass es keine Alternativen gäbe. FreeRTOS und ChibiOS
> gibt es unter der GPL und ersteres sogar mit "static linking exception".
> RTX oder Nuttx gibt es unter Apache- bzw. BSD-Lizenz komplett zur freien
> Verfügung.

Tatsächlich arbeiten wir schon mit Unis zusammen und embOS wird in 
Vorlesungen usw. eingesetzt. Wenn man die Grundlagen eines RTOS erklären 
möchte ist es erstmal egal, welches RTOS man nimmt. Es geht ja nicht 
darum im Studium die API eines Produktes auswendig zu lernen und danach 
nie wieder etwas anderes benutzen zu können. Und wenn man so denkt macht 
es sogar noch mehr Sinn Werkzeuge in der Lehre einzusetzen, die man 
später auch im Berufsleben im kommerziellen Einsatz benutzt. Da spielen 
aber auch noch andere Sachen mit rein, weil wir die Unis mit weiter 
Software und Hardware ausstatten oder auch mal eine Vorlesung übernehmen 
können.

[Wühlhase (Gast)]

Til S. schrieb:
> Wühlhase schrieb:
>> Til S. schrieb:
>>> Richtig, embOS ist ein kommerzielles Produkt aber die Trial Version ist
>>> auf unserer Webseite frei verfügbar. Wir unterstützen ja bereits
>>> Hobbyisten mit z.B. Embedded Studio. Ähnliches könnten wir auch mit
>>> embOS machen.
>> Das wäre prima. :)
>
> Ist die Trial Limitierung für euch Hobbyisten eigentlich ein Problem? Im
> Moment ist es so, dass embOS nach 12 Stunden den Betrieb einstellt, wenn
> mehr als drei Tasks gestartet werden. Das ist für eine Evaluierung kein
> Problem aber ich kann mir vorstellen, dass dies für manche Projekte
> unpraktisch ist.

Grundsätzlich freu ich mich ja erstmal, wenn Firmen ihre (i.d.R. 
kostenintensiven) Werkzeuge auch für Hobbyisten zugänglich machen.
Ob die Limitierung ein Probelm ist kommt auf die Limitierung an.

Als du embOS und Trial erwähnt hast hab ich erstmal an eine zeitliche 
Beschränkung gedacht-das ist natürlich nicht zu gebrauchen.
Ob drei Threads zu wenig sind...kann ich nicht sagen.

Grundsätzlich ist es aber schon so, daß es zumindest mir eher 
schwerfällt, wieder auf ein "niedrigeres" Niveau abzusteigen wenn ich 
mal mit richtigem Werkzeug gearbeitet habe. Man hat halt an seine Arbeit 
auch Ansprüche...

Mal eine Frage: Es gibt vom JLink ja die Edu-Version (hab ich zwar grad 
noch zur Verfügung, aber das ist leider nicht meiner), meines Wissens 
nach wird der aber lieber an Institute/Unis verkauft und ungern an 
Private (selbst wenn diese einen Studentenausweis vorlegen können). Hat 
sich da mittlerweile was geändert?

Sonst wäre es ja vielleicht auch eine Option, einen JLink nur für 
nichtkommerzielle Projekte an Private zu verkaufen (kann ja gern 
knallrot oder so sein), und Sachen wie embOS wären für Private 
dahingehend beschränkt, daß sie eben nur mit dem knallroten JLink 
benutzt werden können und wer Geld mit dem Kram verdienen will, bezahlt 
halt die gewerbliche Lizenz.

Ist zwar sicher nicht wenig Aufwand, da ihr euch allerdings schon die 
Mühe gemacht habt den STLink umprogrammieren zu können...

[Til S. (Firma: SEGGER) (til_s)]

Wühlhase schrieb:
> Grundsätzlich freu ich mich ja erstmal, wenn Firmen ihre (i.d.R.
> kostenintensiven) Werkzeuge auch für Hobbyisten zugänglich machen.
> Ob die Limitierung ein Probelm ist kommt auf die Limitierung an.
>
> Als du embOS und Trial erwähnt hast hab ich erstmal an eine zeitliche
> Beschränkung gedacht-das ist natürlich nicht zu gebrauchen.
> Ob drei Threads zu wenig sind...kann ich nicht sagen.

Die Limitierung bezieht sich wie gesagt darauf, dass wenn man mehr als 
drei Tasks startet, stoppt embOS nach 12 Stunden. Ansonsten gibt es 
keinen Unterschied zu der normalen Version, der Rest ist zu 100% 
identisch.

Wühlhase schrieb:
> Grundsätzlich ist es aber schon so, daß es zumindest mir eher
> schwerfällt, wieder auf ein "niedrigeres" Niveau abzusteigen wenn ich
> mal mit richtigem Werkzeug gearbeitet habe. Man hat halt an seine Arbeit
> auch Ansprüche...

Die Frage wäre ja, ob man überhaupt auf ein niedrigeres Niveau wieder 
absteigen muss. Man könnte ja embOS für seine Projekte zu Hause 
einsetzen und auch später im Job.

Wühlhase schrieb:
> Mal eine Frage: Es gibt vom JLink ja die Edu-Version (hab ich zwar grad
> noch zur Verfügung, aber das ist leider nicht meiner), meines Wissens
> nach wird der aber lieber an Institute/Unis verkauft und ungern an
> Private (selbst wenn diese einen Studentenausweis vorlegen können). Hat
> sich da mittlerweile was geändert?

Nö, eine solche Einschränkung gab es noch nie. Den kann jeder ganz 
normal kaufen. Wir verkaufen den nur nicht direkt, weil das zuviel 
Aufwand wäre. Kaufen kannst du den aber genauso wie den J-Link EDU Mini 
über die Distributoren.

Wühlhase schrieb:
> Sonst wäre es ja vielleicht auch eine Option, einen JLink nur für
> nichtkommerzielle Projekte an Private zu verkaufen (kann ja gern
> knallrot oder so sein), und Sachen wie embOS wären für Private
> dahingehend beschränkt, daß sie eben nur mit dem knallroten JLink
> benutzt werden können und wer Geld mit dem Kram verdienen will, bezahlt
> halt die gewerbliche Lizenz.

Genau das machen wir ja mit J-Link EDU und J-Link EDU Mini ;-). embOS 
möchte ich eigentlich ungern an den J-Link binden, da es ja genügend 
embOS Ports bzw. Cores gibt, bei denen du mit einem J-Link nichts 
anfangen kannst.
Es soll für euch ja möglichst einfach sein. Einfach embOS downloaden, 
nicht kommerziell benutzen und glücklich sein.

[Wühlhase (Gast)]

Til S. schrieb:
> Wühlhase schrieb:
>> Grundsätzlich ist es aber schon so, daß es zumindest mir eher
>> schwerfällt, wieder auf ein "niedrigeres" Niveau abzusteigen wenn ich
>> mal mit richtigem Werkzeug gearbeitet habe. Man hat halt an seine Arbeit
>> auch Ansprüche...
>
> Die Frage wäre ja, ob man überhaupt auf ein niedrigeres Niveau wieder
> absteigen muss. Man könnte ja embOS für seine Projekte zu Hause
> einsetzen und auch später im Job.
Naja, wie gesagt, mit einem RTOS hab ich noch nie gearbeitet, ich kenne 
dieses "Absteigen" aber bei Produkten von anderen Firmen. Ich bin in der 
Hardware-Konstruktion ungemein durch Altium verwöhnt. Die haben auch 
eine Hobbyisten-Version, allerdings mit reduziertem Funktionsumfang. An 
die kam ich bisher partout nicht heran, da in der doch ein paar 
Werkzeuge fehlen die ich gern und exessiv genutzt habe. Obgleich die 
Hobbiversion immer noch mehr kann als z.B. Eagle in der höchsten 
Ausbaustufe...

Ich muß zu meiner Verteidigung aber auch sagen daß ich bisher nicht 
allzuviel Bedarf hatte, privat eine Leiterkarte zu konstruieren.


Til S. schrieb:
> Wühlhase schrieb:
>> Mal eine Frage: Es gibt vom JLink ja die Edu-Version (hab ich zwar grad
>> noch zur Verfügung, aber das ist leider nicht meiner), meines Wissens
>> nach wird der aber lieber an Institute/Unis verkauft und ungern an
>> Private (selbst wenn diese einen Studentenausweis vorlegen können). Hat
>> sich da mittlerweile was geändert?
>
> Nö, eine solche Einschränkung gab es noch nie. Den kann jeder ganz
> normal kaufen. Wir verkaufen den nur nicht direkt, weil das zuviel
> Aufwand wäre. Kaufen kannst du den aber genauso wie den J-Link EDU Mini
> über die Distributoren.
Ah, Fehlinformation, sehr gut zu wissen. Dann werd ich mir demnächst mal 
einen eigenen JLink besorgen... :)

[Til S. (Firma: SEGGER) (til_s)]

Wühlhase schrieb:
> Die haben auch
> eine Hobbyisten-Version, allerdings mit reduziertem Funktionsumfang. An
> die kam ich bisher partout nicht heran, da in der doch ein paar
> Werkzeuge fehlen die ich gern und exessiv genutzt habe.

So etwas hasse ich auch und deswegen machen wir das auch nicht. Bei 
Embedded Studio gibt es ja z.B. keine Codesize Limitierung wie bei 
anderen IDEs (und bei embOS bin ich ja gerade am überlegen, was wir da 
machen können).

[Wühlhase (Gast)]

Ich hab mal noch eine Frage zum STM32, bevor ich meinen nächsten Versuch 
hier reinstelle (falls ich das gleihe Problem wie einst habe):

Bei den GPIOs: was ist der Unterschied zwischen GPIOx_ODR und GPIOx_BSRR 
?
ODR sollte ist das Output Data Register, klar, aber aus irgendeinem 
Grund hab ich damals daß BSRR verwendet-ich vermute, weil ich den 
Ausgang mit ODR nicht gesetzt bekommen hab.

Noch mal eine Frage zu ES: Wie bekomme ich die 
Code-Autovervollständigung wieder rein? Kommt zwar oft automatisch, 
manchmal will ich sie aber auch manuell einblenden wenn sie nicht da 
ist. Bisher behelfe ich mir damit, ein Zeichen zu löschen und wieder 
einzutippen, aber das ist uncool...

[Til S. (Firma: SEGGER) (til_s)]

Wühlhase schrieb:
> Noch mal eine Frage zu ES: Wie bekomme ich die
> Code-Autovervollständigung wieder rein? Kommt zwar oft automatisch,
> manchmal will ich sie aber auch manuell einblenden wenn sie nicht da
> ist. Bisher behelfe ich mir damit, ein Zeichen zu löschen und wieder
> einzutippen, aber das ist uncool...

Ehrlich gesagt mache ich das auch immer so ;-).
Wie ich aber gerade von meinen Embedded Studio Kollegen gelernt habe 
kannst du einfach den Shortcut "STRG + J" benutzen. Probier das mal aus.

[Christopher J. (christopher_j23)]

Wühlhase schrieb:
> Bei den GPIOs: was ist der Unterschied zwischen GPIOx_ODR und GPIOx_BSRR
> ?
> ODR sollte ist das Output Data Register, klar, aber aus irgendeinem
> Grund hab ich damals daß BSRR verwendet-ich vermute, weil ich den
> Ausgang mit ODR nicht gesetzt bekommen hab.

BSRR ist "write-only", d.h. du kannst damit einen Output (oder auch 
mehrere) in einem Aufwasch setzen oder löschen, ohne das vorher ein 
Register gelesen werden muss.

Beispiel:

// Pin 4 von GPIOB auf high setzen (set)
GPIO->ODR |= GPIO_ODR_ODR4;
// oder alternativ mit BSRR
GPIO->BSRR = GPIO_BSRR_BS4;

// Pin 4 von GPIOB auf low setzen (reset)
GPIO->ODR &= ~(GPIO_ODR_ODR4);
// oder alternativ mit BSRR
GPIO->BSRR = GPIO_BSRR_BR4;

Das |= bzw. &= bedeutet ja jeweils soviel wie
1. Register lesen
2. UND-/ODER-Verknüpfung von Register mit Wert
3. Register schreiben

Bei BSRR reduziert sich das auf
1. Register schreiben

[Wühlhase (Gast)]

Til S. schrieb:
> Wühlhase schrieb:
>> Noch mal eine Frage zu ES: Wie bekomme ich die
>> Code-Autovervollständigung wieder rein? Kommt zwar oft automatisch,
>> manchmal will ich sie aber auch manuell einblenden wenn sie nicht da
>> ist. Bisher behelfe ich mir damit, ein Zeichen zu löschen und wieder
>> einzutippen, aber das ist uncool...
>
> Ehrlich gesagt mache ich das auch immer so ;-).
> Wie ich aber gerade von meinen Embedded Studio Kollegen gelernt habe
> kannst du einfach den Shortcut "STRG + J" benutzen. Probier das mal aus.
Is ja nicht wahr... :D Ich hab sehr herzlich gelacht als ich das heute 
auf der Arbeit las. Und noch eine Frage...wo hätte ich das in der Doku 
finden können? Ist ja nicht so daß ich nicht vorher geschaut hätte...

Und noch etwas...ist ES eigentlich eine Eigenentwicklung von euch oder 
setzt ihr da auf ein anderes Tool auf? Mir war ich hätte da mal was 
gelesen in der Richtung.
Der Hintergrund ist folgender: Embedded Studio ist leider ein etwas 
unglücklicher Name, wenn man etwas im Internet sucht. Google findet 
einen Riesenhaufen zu Embedded Studio, leider aber meist was mit True 
Studio, Visual Studio, usw. Womöglich findet man zu grundlegenen Dingen 
schneller etwas, wenn man "den großen Bruder" weiß so es ihn denn 
gibt...

Nicht falsch verstehehn, ich find euer Supportforum klasse und hab da 
fast immer recht schnell Hilfe von euch bekommen (und das trotz 
Privatlizenz). Allerdings hab ich das eher ungern in Anspruch genommen 
da das oft sehr grundlegene Dinge (sowas aus der RTFM-Kategorie) waren, 
sich die Hilfe aber zumindest in meinem Fall oft als nicht so richtig 
hilfreich erwiesen hat. Und wie das mit der Internet-Suche aussieht hab 
ich ja eben geschildert...


@ Christopher Johnson:
Vielen Dank für die Erklärung...jetzt weiß ich Bescheid. :)

Ich glaub ich hätte hier viel früher nachfragen sollen...

[Wühlhase (Gast)]

Und noch eine Frage:
Im Beispiel von Pegel wird im Code auf ein Register "CRH", scheint ein 
GPIO-Register zu sein. Emedded Studio scheint dieses Register nicht zu 
kennen.

Benutzt ES/Segger/andere IDEs eigene Bibliotheken, sodaß die vereinzelt 
voneinander abweichen? Oder ist das einfach nur was anderes (wg. anderem 
Prozessor)?

Auch sowas kennt ES nicht:

RCC->APB2ENR |= RCC_APB2ENR_IOPAEN | RCC_APB2ENR_IOPCEN;

Das APB2ENR zwar, ja, aber was IOPAEN sein soll kann ich nur 
mutmaßen-anscheinend die Ports A und C, die mit Takt versorgt werden, 
aber mit IOPxEN hat da wohl wer sein eigenes Süppchen gekocht?

[pegel (Gast)]

Dazu siehe jeweiliges Reference Manual:

F100RB -> RM0041

F446xx -> RM0390

Die Register unterscheiden sich, je nach Familie.

[Wühlhase (Gast)]

Ohje...langsam ahne ich wofür die HAL da ist... :(

Aber seis drum, der Timer-Interrupt funktioniert jetzt endlich, 
HURRAAAA! :)
Lief sogar sofort, gleich beim ersten Schuß-ich hatte früher die 
IRQ-Funktion falsch deklariert und es nicht gemerkt. Ich hab mich damals 
ahnunglos zu sehr an einem Beispiel für einen anderen Controller 
entlanggehangelt.


Eine Bitte hätte ich noch...kann mal jemand über diesen Codeschnipsel 
sehen?

void main(){
  initClock();
  initNVIC();
  initPins();
  initTimer();

  TIM6 -> CR1 |= TIM_CR1_CEN;

  //Test Pin Init
  while(1){
    //Set a led for testing
    if(!(BUTTON1_PORT -> IDR & BUTTON1_PIN_IDR)){
      LED_RACE_PORT -> BSRR = LED_RACE_BSRR_BR;
    }
    else{
      LED_RACE_PORT -> BSRR = LED_RACE_BSRR_BS;
    }
  }
}

Das ist meine main derzeit. Kann mir irgendwer erklären warum die 
while-Schleife nur ein einziges Mal durchläuft?

Die Tasterabfrage an Button1 funktioniert, ich kann es prüfen wenn ich 
den Controller resette und den Button gedrückt halte.

[Wühlhase (Gast)]

Ich seh grad, ohne den Defines kann mit dem Code ja niemand was 
anfangen...sorry.


Wie macht ihr das mit den Defines eigentlich...ich hab mir jetzt einige 
Defines geschrieben um einerseits nicht jedesmal den ganzen Code ändern 
muß, andererseits liest sich das so auch besser-ich hab keine Lust, mir 
dauernd merken zu müssen an welchem Pin jetzt die LED oder der Taster 
hängt.

Jetzt merk ich aber daß das recht viele Defines werden. Wie macht ihr 
daß denn eigentlich bei größeren Projekten?

[Til S. (Firma: SEGGER) (til_s)]

Wühlhase schrieb:
> Und noch eine Frage...wo hätte ich das in der Doku
> finden können? Ist ja nicht so daß ich nicht vorher geschaut hätte...

Das ist tatsächlich nicht auf Anhieb zu finden. Ich werde die Embedded 
Studio Kollegen fragen.

Wühlhase schrieb:
> Und noch etwas...ist ES eigentlich eine Eigenentwicklung von euch oder
> setzt ihr da auf ein anderes Tool auf? Mir war ich hätte da mal was
> gelesen in der Richtung.

Embedded Studio basiert auf Rowley CrossWorks aber wurde in vielen 
Punkten, wie z.B. einfachere Bedienung, verbessert. Ich persönlich war 
schon früher Fan von Rowley CrossWorks und mir gefällt die 
Geschwindigkeit von Embedded Studio sehr. IAR EWARM zum Beispiel ist 
auch nicht schlecht, aber im Vergleich dauert das immer ewig, wenn man 
eine Debug Session startet oder beendet.

Wühlhase schrieb:
> Der Hintergrund ist folgender: Embedded Studio ist leider ein etwas
> unglücklicher Name, wenn man etwas im Internet sucht. Google findet
> einen Riesenhaufen zu Embedded Studio, leider aber meist was mit True
> Studio, Visual Studio, usw.

Versuche es mal stattdessen mit "Segger Embedded Studio". Da findet man 
mehr über Google. Oder einfach uns fragen ;-).

Wühlhase schrieb:
> Allerdings hab ich das eher ungern in Anspruch genommen
> da das oft sehr grundlegene Dinge (sowas aus der RTFM-Kategorie) waren,
> sich die Hilfe aber zumindest in meinem Fall oft als nicht so richtig
> hilfreich erwiesen hat.

Wenn grundlegende Dinge nicht selbsterklärend sind oder nicht einfach in 
der Dokumentation zu finden sind, sind wir ja dankbar für jede Frage! 
Denn nur so kann das Produkt besser werden und indirekt hilfst du damit 
auch allen anderen Benutzern, egal ob kommerziell oder privat.

[Walter T. (nicolas)]

Wühlhase schrieb:
> Kann mir irgendwer erklären warum die
> while-Schleife nur ein einziges Mal durchläuft?

Aus dem Quelltext nicht. Schuß ins Blaue: Die Timer-ISR wird nicht 
angesprungen oder verursacht einen Fehler.

Solltest Du einen Debugger haben, kannst Du das aber schnell am 
Stack-Trace überprüfen.



Wühlhase schrieb:
> Jetzt merk ich aber daß das recht viele Defines werden. Wie macht ihr
> daß denn eigentlich bei größeren Projekten?

Defines in die Header-Dateien. Dafür sind sie da.

[Wühlhase (Gast)]

@Walter:
Ja, das wars...Interruptflag in der Timer-ISR nicht zurückgesetzt.

Mit den Defines...ich komme mir vor als würde ich einen Teil der 
Bibliotheken noch eimal schreiben. Da dachte ich, ich frag mal wie 
andere das machen. Klar kommen die Defines in die Headerdateien...

Da würde ich wieder eine echte Daseinsberechtigung für Codegeneratoren 
wie Cube sehen (wenn das Ding nicht nur diese HAL verwenden würde...). 
Da kann man seine Pins auch benamsen und braucht Standardbezeichnungen 
wie PA10 nicht mehr. Das würde einiges an Handarbeit sparen.


@Til:
Nun, dann hätte ich noch eine kleine Liste mit Wünschen/Anmerkungen:

Wunsch:
Änderbares Farbthema. Ich weiß, die Farben des Editors kann man ändern, 
ich meine aber die ganze IDE. Ich persönlich empfinde ein zappendusteres 
Farbthema als deutlich angenehmer, wenn man längere Zeit am Bildschirm 
verbringt. Es wäre super, wenn man wenigstens ein zweites, dunkles Thema 
zur Auswahl hat.

Wunsch/Frage:
Wie sieht es mit Unterstützung bei Refakturierung aus? Außer der 
Ersetzen-Funktion habe ich da nichts finden können. Und die ersetzt nur 
innerhalb einer Datei, nicht projektweit, wobei ich mir bei 
Refakturierung noch weitreichenderes wünschen würde. Z.B. wenn ich eine 
Datei umbenenne, sollten die entsprechenden #includes ebenfalls 
überarbeitet werden. Auch das Verschieben einer Funktion in eine andere, 
eingebundene Datei könnte gerne automatisiert sein. Ebenso wie das 
aufspüren verwaister includes, aus denen nix mehr aufgerufen wird.

Frage/Anmerkung:
Die Suchen-Funktion...was tut dieses komische kleine Fenster, wenn ich 
einmal Strg+f drücke? Ich hab in der Doku sowie im Internet ewig und 
immer wieder mal gesucht, aber nie gefunden wie ich andere 
Suchergebnisse anspringen kann.
Bis ich dann, rein zufällig, rausgefunden habe daß man Strg+f auch 
zweimal drücken kann...
Leider sucht die Suche nur in einer Datei, nicht 
projektweit...zumindest, soweit ich das bisher herausgefunden habe. Das 
fehlt meines Erachtens noch.

Wunsch:
Die Anzeige der Dokumentation in der Autocodevervollständigung. Ähnlich, 
wie Netbeans das z.B. mit Javadocs macht. In Java ist die Doku immerhin 
im Sprachstandard festgelegt (im Gegensatz zu C), allerdings gibt es 
auch Tools wie Doxygen, vielleicht ließe sich sowas in der Art 
einbinden.

Wunsch:
Codemap.

Wunsch/Frage:
Ein Fenster, daß einem alle TODOs anzeigt. Die rot zu markieren ist 
nicht schlecht-aber eine Zusammenfassung/Übersicht aller TODOs innerhalb 
des Projekts wäre super, dann übersieht man nix. Bzw. wenn es sowas 
schon gibt-wo finde ich das?

Wunsch:
Etwas, was ich bisher von keiner IDE kenne, ich überlege ob ich sowas 
mal für Netbeans schreibe (wobei ich unter Java sowas nur selten 
gebraucht hätte, allerdings unter VBA oder hier, bei meinem STM, brauch 
ich sowas öfter. Wenn ich eine Menge von gleichartigen Ausdrücken habe, 
die sich nur in einer Kleinigkeit unterscheiden, ein sehr einfaches 
Beispiel:

  bool button1wasTapped(void);
  bool button2wasTapped(void);
  bool button3wasTapped(void);
  bool button4wasTapped(void);
  bool button5wasTapped(void);

Da würde ich mir wünschen daß ich eine solche Zeile nur einmal eingeben 
müßte, einen Laufindex von...bis und die IDE diesen Codeschnipsel selber 
schreibt.
Das Beispiel ist trivial und wäre auch mit Copy+Paste gut zu machen, 
anders sieht es dann aber schon bei solchen Konstrukten aus:

  #define LED_ERR_PORT GPIOE
  #define LED_ERR_PIN 2
  #define LED_ERR_BSRR_BS GPIO_BSRR_BS2
  #define LED_ERR_BSRR_BR GPIO_BSRR_BR2
  #define LED_ERR_ODR GPIO_ODR_OD2
  #define LED_ERR_IDR

  #define LED_TEST_PORT GPIOE
  #define LED_TEST_PIN 3
  #define LED_TEST_BSRR_BS GPIO_BSRR_BS3
  #define LED_TEST_BSRR_BR GPIO_BSRR_BR3
  #define LED_TEST_ODR GPIO_ODR_OD3
  
  #define LED_RACE_PORT GPIOE
  #define LED_RACE_PIN 4
  #define LED_RACE_BSRR_BS GPIO_BSRR_BS4
  #define LED_RACE_BSRR_BR GPIO_BSRR_BR4
  #define LED_RACE_ODR GPIO_ODR_OD4

Das sind nur drei LEDs...und ich hab deren sieben. Ein Werkzeug, daß da 
meiner Faulheit entgegenkommt, wäre grandios.

Mir fällt grad auf daß das weitaus mehr Wünsche als Fragen sind-Fragen 
fallen mir grad kaum ein. Das wird sich aber noch im Laufe dieses Tages 
bestimmt ändern, ich trags dann nach.

Die Geschwindigkeit von ES mag ich auch-wobei ich längere Ladezeiten 
gern akzeptiere wenn es während der Arbeit flüssig läuft und der 
Gegenwert gerechtfertigt ist.
Crossworks und EWARM kenne ich nicht, ich arbeite aber viel mit 
Netbeans. Das braucht zwar gefühlt ewig zum Starten (ok, läuft halt auch 
auf der JVM) und dem Vorbereiten einer Debug- oder Testsession, läuft 
ansonsten während der Arbeit aber gut und kann halt irre viel, nimmt 
einem Arbeit ab wo es nur geht und macht einem das Zurechtfinden in 
größeren Projekten einfach. Frißt halt auch Speicher, bei mir sinds 
aktuell 692MB vs. 83MB (wobei ich Netbeans noch zu Gute halten muß daß 
ich da deutlich mehr Dateien offen habe). Ist halt der Preis für ein 
mächtiges Werkzeug...

Wobei ich ES aber auch mal loben muß, es hat wirklich ein paar sehr 
nette Extras. Was mir sehr gut gefällt ist, daß man aus ES heraus die 
Datenblätter/Dokumentation öffnen kann. Auch daß die Projekte nach dem 
Erstellen schon debug-fähig vorbereitet sind find ich klasse. :)

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Wühlhase schrieb:
> #define LED_ERR_BSRR_BS GPIO_BSRR_BS2
>   #define LED_ERR_BSRR_BR GPIO_BSRR_BR2

Das bringt dich ja auch nicht viel weiter. Schreib doch stattdessen:

#define LED_ERR_ON GPIO_BSRR_BS2
#define LED_ERR_OFF GPIO_BSRR_BR2

Dann wird der Code lesbar und wenn die defines einmal stimmen, fällt 
alles an seinen Platz.

[Wühlhase (Gast)]

Gute Idee...danke, so mach ich das. :)

[Walter T. (nicolas)]

Wühlhase schrieb:
> Wenn ich eine Menge von gleichartigen Ausdrücken habe,
> die sich nur in einer Kleinigkeit unterscheiden,

...dann ist das ein Zeichen dafür, daß man eine Pause machen sollte, 
einen Kaffee trinken oder so, und seine Lösung noch einmal vom weiten 
betrachten.

"Don't repeat yourself" (DRY), wie es so schön heißt.

[Wühlhase (Gast)]

Stimmt oft, andererseits: Wie würdest du es sonst machen? Wenn du fünf 
Buttons oder so hast liegt es nahe, fünf mal etwas ähnliches zu haben.

[Walter T. (nicolas)]

Wühlhase schrieb:
> Wie würdest du es sonst machen?

Naja, also bei mir habe ich eine Funktion "getButton(int)" und mit einem 
Integer (Enum) suche ich mir aus, welchen Taster ich wirklich auslesen 
will.

Das bedeutet z.B. auch bei der Entprellung, daß ich einfach mit einer 
for-Schleife alle n Buttons pollen kann.

[Wühlhase (Gast)]

So mache ich das sogar gerade.

Allerdings muß ich ja irgendwo mein Programm mit den "echten" Registern 
verbinden. Meine Überlegungen waren zuerst, mich von meiner Pin-Belegung 
unabhängiger zu machen (daher auch Defines sowohl für ODR und BSRR). 
Obwohl es allerdings unwahrscheinlich ist, daß sich die Pinbelegung 
nochmal ändert. So muß ich nur einmal die Defines irgendwo ändern, die 
Codeleserlichkeit hatte ich, zugegeben, nicht im Blick.

[Walter T. (nicolas)]

Da die GPIO-Basisadresse und die Register ODR, BSRR, IDR usw. immer 
denselben Offset haben, reicht es, wenn Du Dir nur GPIOx und die Pins 
definierst:

#define LED0_GPIO GPIOC
#define LED0_Pin  GPIO_Pin_11


void foo(void)
{
    LED0_GPIO->ODR ^= LED0_Pin;
    LED0_GPIO->BSRRH = LED0_Pin; 
}

[Til S. (Firma: SEGGER) (til_s)]

Wühlhase schrieb:
> @Til:
> Nun, dann hätte ich noch eine kleine Liste mit Wünschen/Anmerkungen:

Danke, da sind ein paar gute Punkte dabei.
Ich gebe das mal an meine Embedded Studio Kollegen weiter und halte euch 
hier in diesem Thread auf dem Laufenden. Oder sollen wir das besser über 
Email, Newsletter, Notification List, unser Forum, Twitter, ... machen? 
Vielleicht gibt es ja auch hier im Forum einen Bereich, in dem wir uns 
über ES austauschen können? Ein eigener Thread? Ein Artikel?

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Til S. schrieb:
> Vielleicht gibt es ja auch hier im Forum einen Bereich, in dem wir uns
> über ES austauschen können?

Die 'Compiler & IDE' Ecke ist dafür gedacht.

[Wühlhase (Gast)]

Til S. schrieb:
> Ich gebe das mal an meine Embedded Studio Kollegen weiter und halte euch
> hier in diesem Thread auf dem Laufenden. Oder sollen wir das besser über
> Email, Newsletter, Notification List, unser Forum, Twitter, ... machen?
> Vielleicht gibt es ja auch hier im Forum einen Bereich, in dem wir uns
> über ES austauschen können? Ein eigener Thread? Ein Artikel?
Das wäre prima, wenn du/ihr berichtest. Und danke fürs weiterleiten.
Vieles, was ich da oben aufgelistet habe, kenne ich übrigens aus 
Netbeans (da fällt mir ein, der Java-Debugger hat auch noch ein paar 
sehr nette Extras, die selbigen in ES sicher noch ergänzen können, z.B. 
hinsichtlich Variablenüberwachung).

Wenn ihr twittert-könnt ihr gerne, ich allerdings bin da außen vor -> 
weil kein Twitter-Account.

Ansonsten würde ich fast vorschlagen, hier einfach einen Thread 
aufzumachen wenn es etwas neues gibt (vielleicht nicht dauernd einen 
neuen Thread, aber vllt einen und den immer wieder aktualisieren).
Das wird zwar von einigen Benutzern hier wahrscheinlich als dreiste 
Werbung bewertet werden, andererseits kann ja jeder zumindest einen Teil 
eurer Produkte frei nutzen-selbst in einen JLink muß man nicht zwingend 
investieren, und selbst diese Nutzer kriegen Hilfe.

Thread/Artikel innerhalb dieses Forums fände ich nicht schlecht, 
immerhin ist das Forum der direkte Informationskanal. Frag doch Andreas 
mal was er davon hält. Vielleicht fret sich Andreas sogar über einen 
Artikel, soviel ist im News-Bereich ja nun auch wieder nicht los.