🍀 👩🏼‍🤝‍👩🏻 🤕 マイクロコントローラーの小さなプロジェクトにCの代わりにC ++を使用することは可能ですか？ 🌔 🍜 🌳

マイクロコントローラ用のソフトウェアの開発でC ++を使用することは、スズメに銃を撃つようなものだという意見があります。コードは大きくて不器用であることがわかりますが、RAMまたはROMのすべてのビットを争うことに慣れています。また、マイクロコントローラーのソフトウェアは、必然的にCで作成できます。実際、C言語はアセンブラーの代替として考えられていました。コードはコンパクトで高速である必要があり、開発の読みやすさと使いやすさにより、かなり大きなプログラムを簡単に書くことができました。しかし、結局のところ、アセンブラーの開発者がCについて同じことを言った後、大量の水が流れ、アセンブラーのみを使用するプログラマーを指で数えることができるようになりました。もちろん、アセンブラーは、RTOSを記述して高速並列コンピューティング用のコードを開発する上で重要な役割を果たしますが、これはむしろルールの例外です。 Cがファームウェアの標準として使われたように、C ++はこの領域で既にCを置き換えることができます。 C ++ 14標準および最新のコンパイラのC ++には、コンパクトなコードを作成する十分な手段があり、Cで作成されたコードよりも効率が悪くなることはありません。以下は、最適化が無効になっているARM 8.20コンパイラのIARで、2つのCおよびC ++言語の5つの整数の配列の最小数を見つけるためのコードです。

156バイトのCコード

int main(void) { int testArray[5U] = {-1,20,-3,0,4}; int lowest = INT_MAX; for (int i = 0; i < 5; i++) { lowest = ((lowest < testArray[i]) ? lowest : testArray[i]); }; return 0;

そして、そのアセンブラー表現

152バイトを占めるC ++コード

 int main() { int testArray[5U] = {-1, 20, -3, 0, 4}; int lowest = std::numeric_limits<int>.max(); for (auto it: testArray) { lowest = ((lowest < it) ? lowest : it); }; return 0;

そして、そのアセンブラー表現

ご覧のとおり、コンパイラによって生成されたC ++コードは4バイト少なく、速度は12クロックサイクル高速です。これらはすべて、C ++ 14の新機能により実現されています。もちろん、両方のコンパイラの最適化がオフになっていることがわかります。これは実際の実装とは関係のない非常に総合的なテストですが、すべてがそれほど単純ではないということは言えます。

マイクロコントローラのプログラミング機能を考慮する必要があります。少量のプログラムメモリ32.64..512 kB、さらに少ないRAMおよびマイクロプロセッサの低周波数（特に低電力センサーに使用する場合）の要件により制限が課せられるためです。そして、自信を持って、すべてのC ++機能が役立つとは限りません。たとえば、標準テンプレートライブラリを使用すると、大量のリソースを消費する可能性があります。また、例外ハンドラなどの情報を格納するためにスタックとコードのサイズを大幅に増やす必要があるため、小さなマイクロコントローラーのプロジェクトから例外が安全にスローされる可能性があるなど、大きなC ++の世界では彼のさらなる検索。したがって、小規模なプロジェクトでC ++とその新機能を使用する方法を説明し、良心の揺らぎがなければCの代わりにC ++を使用できることを示します。

タスクを決定するために最初に必要なこと。それは十分にシンプルである必要がありますが、たとえば、 マクロを完全に放棄し 、ポインタから逃げる、愚かなエラーのリスクを減らすなどの方法を示すのに十分なものでなければなりません...

いつものように、選択肢はLEDにかかっていました。

読者が私たちが何をしたいのかを理解するために、マイクロコントローラーに実装しなければならないタスクの最終バージョンを示します。

中古ボードXNUCLEO-F411RE
ソフトウェアは、16 MHzの外部周波数で動作するSTMF411Rマイクロプロセッサで実行する必要があります。
ソフトウェアは、ポートに接続されたボード上の4つのLED（LED 1-GPIOA.5、LED 2-GPIOC.9、LED 3-GPIOC.8、LED 4-GPIOC.5）の制御をサポートする必要があります。
ソフトウェアは3つのLED制御モードをサポートする必要があります（ヘリンボーン-すべてのLEDが交互に点灯し、次に同じ順序で交互に消灯します。チェス-最初は偶数のLEDが点灯し、奇数のLEDが消灯し、逆も同様です。すべてのモード-すべてのLEDが点灯してから消灯します）。 LEDの状態時間の変更-1秒
ソフトウェアは、Fir-tree-Chess-Allシーケンスで循環順序でGPIOC.13ポートに接続されたボタンを使用して、LED制御モードの変更をサポートする必要があります。

これが、顧客からの最終的な要件の見え方です。しかし、通常は実際に発生するため、最初に顧客はより簡単なアイデアを思いついたため、彼は完全な幸福のために明るい兆候、つまり1秒ごとに緑色のLEDを点滅させることに欠けると判断しました。このタスクは、Snezhinkaという名前のプログラマーによって開始されました。

したがって、ボードには4つのLED、LED1、LED2、LED3、LED4があります。これらはそれぞれポートGPIOA.5、GPIOC.5、GPIOC.8、GPIOC.9に接続されています。ここでは、GPIOAにあるLED1を使用します。

まず、プログラマーのSnezhinkaは、LEDを切り替えるような単純なCコードを作成しました。次のようになります。

 int main() { GPIOC->ODR ^= GPIO_ODR_OD5; //   LED1   Delay(1000U); GPIOC->ODR ^= GPIO_ODR_OD5; // ,    return 0; }

コードはうまく機能し、正しく動作します。Snezhinkaは作業に満足し、休息しました。しかし、ボードの配線とユーザーのブール演算の複雑さが未熟なため、このコードは完全に明確ではないため、SnezhinkaはLEDがGPIOA.5ポートにあることを説明するコメントを追加する必要があり、実際に切り替えたいと考えています。

そのようなコードが人間の言語でどのように見えるかについて考えてみましょう。次のようになります。

 Toggle Led1 then Delay 1000ms then Toggle Led1

ご覧のとおり、ここではコメントは不要であり、そのようなコードの目的は直感的です。最も注目すべきことは、この擬似コードがC ++のコードとほぼ完全に一致することです。見て、唯一の違いは、どのポートがオンになっているかを示すことによって、まずLEDを作成する必要があることです。

 int main() { Led Led1(*GPIOA, 5U); Led1.Toggle(); Delay(1000U); Led1.Toggle(); return 0; }

完全なコード

startup.cpp

 #pragma language = extended #pragma segment = "CSTACK" extern "C" void __iar_program_start( void ); class DummyModule { public: static void handler(); }; typedef void( *intfunc )( void ); //cstat !MISRAC++2008-9-5-1 typedef union { intfunc __fun; void * __ptr; } intvec_elem; #pragma location = ".intvec" //cstat !MISRAC++2008-0-1-4_b !MISRAC++2008-9-5-1 extern "C" const intvec_elem __vector_table[] = { { .__ptr = __sfe( "CSTACK" ) }, __iar_program_start, DummyModule::handler, DummyModule::handler, DummyModule::handler, DummyModule::handler, DummyModule::handler, 0, 0, 0, 0, DummyModule::handler, DummyModule::handler, 0, DummyModule::handler, DummyModule::handler, //External Interrupts DummyModule::handler, //Window Watchdog DummyModule::handler, //PVD through EXTI Line detect/EXTI16 DummyModule::handler, //Tamper and Time Stamp/EXTI21 DummyModule::handler, //RTC Wakeup/EXTI22 DummyModule::handler, //FLASH DummyModule::handler, //RCC DummyModule::handler, //EXTI Line 0 DummyModule::handler, //EXTI Line 1 DummyModule::handler, //EXTI Line 2 DummyModule::handler, //EXTI Line 3 DummyModule::handler, //EXTI Line 4 DummyModule::handler, //DMA1 Stream 0 DummyModule::handler, //DMA1 Stream 1 DummyModule::handler, //DMA1 Stream 2 DummyModule::handler, //DMA1 Stream 3 DummyModule::handler, //DMA1 Stream 4 DummyModule::handler, //DMA1 Stream 5 DummyModule::handler, //DMA1 Stream 6 DummyModule::handler, //ADC1 0, //USB High Priority 0, //USB Low Priority 0, //DAC 0, //COMP through EXTI Line DummyModule::handler, //EXTI Line 9..5 DummyModule::handler, //TIM9/TIM1 Break interrupt DummyModule::handler, //TIM10/TIM1 Update interrupt DummyModule::handler, //TIM11/TIM1 Trigger/Commutation interrupts DummyModule::handler, //TIM1 Capture Compare interrupt DummyModule::handler, //TIM2 DummyModule::handler, //TIM3 DummyModule::handler, //TIM4 DummyModule::handler, //I2C1 Event DummyModule::handler, //I2C1 Error DummyModule::handler, //I2C2 Event DummyModule::handler, //I2C2 Error DummyModule::handler, //SPI1 DummyModule::handler, //SPI2 DummyModule::handler, //USART1 DummyModule::handler, //USART2 0, DummyModule::handler, //EXTI Line 15..10 DummyModule::handler, //EXTI Line 17 interrupt / RTC Alarms (A and B) through EXTI line interrupt DummyModule::handler, //EXTI Line 18 interrupt / USB On-The-Go FS Wakeup through EXTI line interrupt 0, //TIM6 0, //TIM7 f0 0, 0, DummyModule::handler, //DMA1 Stream 7 global interrupt fc 0, DummyModule::handler, //SDIO global interrupt DummyModule::handler, //TIM5 global interrupt DummyModule::handler, //SPI3 global interrupt 0, // 110 0, 0, 0, DummyModule::handler, //DMA2 Stream0 global interrupt 120 DummyModule::handler, //DMA2 Stream1 global interrupt DummyModule::handler, //DMA2 Stream2 global interrupt DummyModule::handler, //DMA2 Stream3 global interrupt DummyModule::handler, //DMA2 Stream4 global interrupt 130 0, 0, 0, 0, 0, 0, DummyModule::handler, //USB On The Go FS global interrupt, 14C DummyModule::handler, //DMA2 Stream5 global interrupt DummyModule::handler, //DMA2 Stream6 global interrupt DummyModule::handler, //DMA2 Stream7 global interrupt DummyModule::handler, //USART6 15C DummyModule::handler, //I2C3 Event DummyModule::handler, //I2C3 Error 164 0, 0, 0, 0, 0, 0, 0, DummyModule::handler, //FPU 184 0, 0, DummyModule::handler, //SPI 4 global interrupt DummyModule::handler //SPI 5 global interrupt }; __weak void DummyModule::handler() { for(;;) {} }; extern "C" void __cmain( void ); extern "C" __weak void __iar_init_core( void ); extern "C" __weak void __iar_init_vfp( void ); #pragma required=__vector_table void __iar_program_start( void ) { __iar_init_core(); __iar_init_vfp(); __cmain(); }

utils.hpp

 #ifndef UTILS_H #define UTILS_H #include <cassert> namespace utils { template<typename T, typename T1> inline void setBit(T &value, T1 bit) { assert((sizeof(T) * 8U) > bit); value |= static_cast<T>(static_cast<T>(1) << static_cast<T>(bit)); }; template<typename T, typename T1> inline void clearBit(T &value, T1 bit) { assert((sizeof(T) * 8U) > bit); value &= ~static_cast<T>(static_cast<T>(1) << static_cast<T>(bit)); }; template<typename T, typename T1> inline void toggleBit(T &value, T1 bit) { assert((sizeof(T) * 8U) > bit); value ^= static_cast<T>(static_cast<T>(1) << static_cast<T>(bit)); }; template<typename T, typename T1> inline bool checkBit(const T &value, T1 bit) { assert((sizeof(T) * 8U) > bit); return !((value & (static_cast<T>(1) << static_cast<T>(bit))) == static_cast<T>(0U)); }; }; #endif

led.hpp

 #ifndef LED_H #define LED_H #include "utils.hpp" class Led { public: Led(GPIO_TypeDef &portName, unsigned int pinNum) : port(portName), pin(pinNum) {}; inline void Toggle() const { utils::toggleBit(port.ODR, pin); } inline void SwitchOn() const { utils::setBit(port.ODR, pin); } inline void SwitchOff() const { utils::clearBit(port.ODR, pin); } private: GPIO_TypeDef &port; unsigned int pin; }; #endif

main.cpp

 #include <stm32f411xe.h> #include "led.hpp" extern "C" { int __low_level_init(void) { //    16  RCC->CR |= RCC_CR_HSION; while ((RCC->CR & RCC_CR_HSIRDY) != RCC_CR_HSIRDY) { } //      RCC->CFGR |= RCC_CFGR_SW_HSI; while ((RCC->CFGR & RCC_CFGR_SWS) != RCC_CFGR_SWS_HSI) { } //       RCC->AHB1ENR |= (RCC_AHB1ENR_GPIOAEN); //LED1  PortA.5,  PortA.5   GPIOA->MODER |= GPIO_MODER_MODE5_0; return 1; } //,       inline void Delay(unsigned int mSec) { for (unsigned int i = 0U; i < mSec * 3000U; i++) { __NOP(); }; } } int main() { Led Led1(*GPIOA, 5U); Led1.Toggle(); Delay(1000U); Led1.Toggle(); return 0; }

ミニマリストのプログラマーは、コードはより理解しやすいと言うかもしれませんが、冗長であり、オブジェクトが作成され、コンストラクター、メソッドが呼び出され、RAMと追加コードの量が生成されます。しかし、アセンブラーのリストを見ると、両方のコンパイラーでインライン関数オプションが有効になっているC ++コードのサイズがCプログラムのサイズと同じであり、メイン関数を呼び出すという特殊性のために、一般的なC +コード+ 1つ少ない命令。

Cソースからのアセンブラーコード

C ++ソースからのアセンブラーコード

これは、最新のコンパイラーが、あなたの素晴らしくて理解しやすいC ++コードを最適なアセンブラーコードに変えるという仕事をしているという事実をもう一度確認します。また、すべてのアセンブラプログラマがこのレベルの最適化を実現できるわけではありません。

もちろん、最適化を無効にすると、C ++コードはスタックサイズと速度の点でそれほどコンパクトになりません。比較のために、コンストラクターとメソッドを呼び出して、最適化されていないバージョンを提供します。

私にとって、センサーファームウェア（どの要素がどのポートに接続されているか、現在の状態がポートまたはこれまたはそのモジュールなど）を記述するために不必要な詳細を頭の中に保持することと、コードの単純さとわかりやすさの間にジレンマはありません。結局、デバイスのロジック、ユーザーインタラクションインターフェイスを記述し、計算を実装する必要がありますが、ADCからデータを読み取るためには、まずGPIOA.3ポートにあるCS信号を使用してそれを選択し、インストールする必要があることを忘れないでくださいその単位。 ADCモジュールの開発者にこれを行わせてください。

最初は、多くの追加コードを書く必要があるように思われるかもしれませんが、アプリケーションがLEDを点滅させるよりも少し複雑になった場合、それは報われる以上です。

割り当てに戻ります。 Snezhinkaは仕事の結果を顧客に示す時間を持っていませんでした。顧客が夜に点滅するLEDの魅力を感じて、クリスマスツリーモードで4つのLEDを点滅させるのは良いことだと判断しました。

複数のプロジェクトを同時に実行しているプログラマーのスネシンカは、信頼性が高く理解しやすい方法であると考えているため、時間を節約し、額を最大限に活用することに決めました。

 #define TOGGLE_BIT(A,B) ((A) ^= (1U << ((B) & 31UL))) #define SET_BIT(A,B) ((A) |= (1U << ((B) & 31UL))) int main(void) { //   SET_BIT(GPIOC->ODR, 5U); SET_BIT(GPIOC->ODR, 8U); SET_BIT(GPIOC->ODR, 9U); SET_BIT(GPIOA->ODR, 5U); //     for (;;) { Delay(1000U); TOGGLE_BIT(GPIOC->ODR, 5U); Delay(1000U); TOGGLE_BIT(GPIOC->ODR, 8U); Delay(1000U); TOGGLE_BIT(GPIOC->ODR, 9U); Delay(1000U); TOGGLE_BIT(GPIO->ODR, 5U); //:   TOGGLE_BIT(GPIOA->ODR, 5U } return 0; }

コードは機能しますが、最後のエントリTOGGLE_BIT（GPIO-> ODR、5U）に注意してください。 LED 1と4はレッグ番号5にありますが、異なるポートにあります。 Ctrl C-Ctrl Vを使用して、Snowflakeは最初のレコードをコピーし、ポートの変更を忘れました。これは、管理者のプレッシャーのもとで作業するプログラマーによる典型的な間違いであり、期限を「昨日」に設定します。問題は、タスクのためにコードを迅速に記述する必要があり、Snezhinkaがソフトウェア設計について考える時間がないため、座って必要なものを書いただけで、ほんの少しのしみを許しました。デバイスのファームウェア。ただし、彼はこれに時間を費やすことを理解する必要があります。さらに、Snezhinkaは2つの恐ろしいマクロを追加しました。これは、彼の意見では作業を容易にします。前のC ++の例では、これらのマクロをすばらしい組み込み関数で置き換えるためのコードなど、非常に多くのコードを追加しました。なんで？

非常に人気のあるビット設定マクロを見てみましょう。これを使用して、任意の整数型のビットを設定できます。

 #define SET_BIT(A,B) (A |= (1 << B)) int main() { unsigned char value = 0U; SET_BIT(value, 10); return 0; }

1つを除いて、すべてが非常に美しく見えます-このコードにエラーがあり、目的のビットが設定されません。 SET_BITマクロを使用して、値変数に10ビットが設定されます。これは、サイズが8ビットです。変数宣言がマクロ呼び出しにそれほど近くない場合、プログラマーはどのくらいこのようなエラーを探すのだろうか？このアプローチの唯一の利点は、コードが最小サイズを占有するという疑いのない事実です。

潜在的なエラーを回避するために、このマクロをテンプレート関数に置き換えましょう

 template<typename T, typename T1> inline void setBit(T &value, T1 bit) { assert((sizeof(T) * 8U) > bit); value |= static_cast<T>(static_cast<T>(1) << static_cast<T>(bit)); };

ここで、組み込みのsetBit関数は、ビットとビット番号を設定するパラメーターへの参照を取ります。この関数は、任意のタイプのパラメーターとビット番号を使用できます。この場合、ビット数がパラメータータイプのサイズを超えないようにするため、つまり、このタイプのパラメーターでビットを確実に設定できるようにするために、アサート関数を使用してチェックを行います。 assert関数は実行時に条件をチェックし、条件が満たされた場合、コードはさらに実行を続けますが、条件が満たされない場合、プログラムはエラーで終了します。 assert関数のプロトタイプの説明は、cassertファイルにあり、接続する必要があります。このようなチェックは、開発中に役立ちます。突然誰かが誤った入力パラメーターを渡すことにした場合、動作中に動作するときにこれに気付くでしょう。製品コードでは、入力パラメーターチェックを使用しても意味がないことは明らかです。これは実行されるため速度が低下し、さらに、開発中に無効なパラメーターを渡す可能性をすべてキャッチしたため、ソースファイルでNDEBUG文字を定義することでアサートを無効にできますまたは、プロジェクト全体に対して定義することにより。

インラインキーワードに注意してください。このキーワードは、コンパイラーに、この関数を組み込みと見なしたいことを伝えます。すなわちコンパイラは単に関数呼び出しをそのコードで置き換えると仮定しますが、実際にはこれはコンパイラの最適化設定でのみ達成できます。 IARワークベンチでは、これはC / C ++コンパイラ->最適化タブの「関数のインライン化」オプションの隣のチェックボックスです。この場合、関数も高速であり、マクロと同じくらいのスペースを占有します。

Snowflakeコードに戻り、拡張性はどのようになっていますか？

スノーフレークコード

 #define TOGGLE_BIT(A,B) ((A) ^= (1U << ((B) & 31UL))) #define SET_BIT(A,B) ((A) |= (1U << ((B) & 31UL))) int main(void) { //   SET_BIT(GPIOC->ODR, 5U); SET_BIT(GPIOC->ODR, 8U); SET_BIT(GPIOC->ODR, 9U); SET_BIT(GPIOA->ODR, 5U); //     for (;;) { Delay(1000U); TOGGLE_BIT(GPIOC->ODR, 5U); Delay(1000U); TOGGLE_BIT(GPIOC->ODR, 8U); Delay(1000U); TOGGLE_BIT(GPIOC->ODR, 9U); Delay(1000U); TOGGLE_BIT(GPIO->ODR, 5U); //:   TOGGLE_BIT(GPIOA->ODR, 5U } return 0; }

結局、どうやら顧客はそこで止まらず、LEDが4ではなく40の場合はどうなりますか？コードサイズは10倍に直線的に増加します。エラーが発生する可能性は同じ量だけ増加し、コードサポートは将来ルーチンになります。

賢明なCプログラマは、次のようなコードを書くことができます。

 int main(void) { tLed pLeds[] = {{ GPIOC, 5U },{ GPIOC, 8U },{ GPIOC, 9U },{ GPIOA, 5U }}; SwitchOnAllLed(pLeds, LEDS_COUNT); for (;;) { for (int i = 0; i < LEDS_COUNT; i++) { Delay(1000U); ToggleLed(&pLeds[i]); } } return 0; }

メイン関数のコードが少なくなり、最も重要なことは、簡単に拡張できるようになったことです。 LEDの数を増やす場合、LEDが接続されているポートをLEDアレイに単純に追加し、マクロLEDS_COUNTをLEDの数に変更するだけで十分です。この場合、コードサイズはまったく増加しません。もちろん、スタック上にLEDのアレイが作成され、すでに56バイトであるため、スタックの深さは大幅に増加します。

最初のソリューションと2番目のソリューションの間には常に選択肢があり、特定の実装にとってより重要です。コードサイズ、拡張性、読みやすさ、簡潔さを小さくするか、RAMサイズと速度を小さくします。私の経験では、90％のケースで最初のものを選択できます。

しかし、このコードを詳しく見てみましょう。これは、ポインターと、SET_BIT（）やTOGGLE_BIT（）などのマクロを使用した典型的なCコードです。これに関連して、潜在的な問題のリスクがあります。たとえば、SwitchOnAllLed関数（tLed * pLed、intサイズ）は、ポインターと配列サイズを受け取ります。まず、この関数にNULLポインターを渡すことを禁止するものは何もないことを理解する必要があります。したがって、ポインターがNULLでないことを確認する必要があります。結局、誤ってポインターを別のオブジェクトに渡すことができます。第二に、プログラマーが配列の宣言されたサイズよりも大きいサイズを突然渡した場合、そのような関数の動作は完全に予測できなくなります。したがって、もちろん、この関数でサイズを確認することをお勧めします。このようなチェックを追加すると、コードが増加します。チェックはassertを使用して行うこともできますが、C ++で同じことを書くことをお勧めします

 int main() { LedsController LedsContr; LedsContr.SwitchOnAll(); for (;;) { for (auto &led : LedsContr.Leds) { Delay(1000U); led.Toggle(); } } return 0; }

はい、このコードはすでに多くのスペースを占有しています。しかし、後でこのような設計がどのように時間を節約するかを確認し、コードサイズはCとほぼ同じになり、プログラムが複雑になります。

ここではLedsControllerクラスが使用されています。そのコードを示します。

 #ifndef LEDSCONTROLLER_H #define LEDSCONTROLLER_H #include "led.hpp" #include <array> constexpr unsigned int LedsCount = 4U; class LedsController { public: LedsController() {}; inline void SwitchOnAll() { for (auto &led : Leds) { led.SwitchOn(); } }; std::array<Led, LedsCount> leds{Led{*GPIOC, 5U},Led{*GPIOC, 8U},Led{*GPIOC, 9U},Led{*GPIOA, 5U}}; }; #endif

SwitchOnAll（）メソッドは、ポインターを配列に渡す必要がなくなり、クラスオブジェクト内に格納されている既存の配列を使用します。

このコードはなぜ信頼性が高いと考えられますか？まず、どこでもポインターを使用せず、クラス内のすべての既存のLEDにオブジェクトの配列を保存し、ポインターではなくオブジェクトを直接参照します。次に、サイズを指定することなく配列をバイパスするforループに特別な構文を使用します;コンパイラーはこれを行います。このループは、反復子であるすべてのオブジェクトで機能します。 C ++の配列は、デフォルトではそのようなオブジェクトです。

間違える可能性がある唯一の場所は、LedsCount定数を使用して配列のサイズを設定することです。ただし、この小さな例からでも、C ++には信頼性の高いコードを記述するためのより多くのツールが用意されていることがわかります。

注意が必要なもう1つの点は、LedsControllerクラスのオブジェクトを誤って作成する可能性があることです。これにより、使用されるRAM（スタック）のサイズが大きくなり、プログラムの興味深い動作が発生します。 Lonerテンプレートはこれに対する保護に役立ちますが、かなり大規模なプロジェクト、大規模な開発チームがあり、誰かがコントローラーオブジェクトが既に作成され、別のコントローラーを誤って作成していることを誰かが忘れるリスクがある場合にのみ、これを行う必要があります。私たちの場合、これは明らかに過剰であり、関数は小さく、LedsControllerクラスのオブジェクトが1つあることをはっきりと覚えています。

しかし、開発に戻ると、通常、プログラマがタスク（この場合はクリスマスツリー）を実現した瞬間に、顧客はすぐにさらに2つのモードを実装するように要求します：チェッカーボードパターンで点滅し、すべてのLEDで点滅し、ボタンを押すだけでモードが変更されます。 Snezhinkaの場合、ほぼ完全なエラーが発生します。プログラムコードをSnezhinkaスタイルで作成すると、この記事のページに収まらないほど面倒になるため、ここでは説明しません。

Cプログラマーが何ができるかをよりよく見ていきます。顧客からさらに新しいオファーが来る可能性があることを理解すると、彼はおそらく次のようなことをします。

 int main(void) { tPort Leds[] = { { GPIOC, 5U },{ GPIOC, 8U },{ GPIOC, 9U },{ GPIOA, 5U } }; tPort Button = { GPIOC, BUTTON_PIN }; //   GPIOC.13 tLedMode Mode = LM_Tree; int currentLed = 0; SwitchOnAllLed(Leds, LEDS_COUNT); for (;;) { //   .    1,    0 if (!CHECK_BIT(Button.pPort->IDR, BUTTON_PIN)) { //   Mode = (Mode < LM_End) ? (tLedMode)(Mode + 1U) : LM_Tree; //      currentLed = 0; switch (Mode) { case LM_Tree: case LM_All: SwitchOnAllLed(Leds, LEDS_COUNT); break; case LM_Chess: SwitchChessLed(Leds, LEDS_COUNT); break; default: break; } } //      switch (Mode) { case LM_Tree: ToggleLed(&Leds[currentLed]); break; case LM_All: case LM_Chess: ToggleAll(Leds, LEDS_COUNT); break; default: break; } currentLed = (currentLed < (LEDS_COUNT – 1)) ? (currentLed + 1) : 0; Delay(300U); } return 0; }

そして、新しいモードを追加するには、新しいリカウンターを追加し、このモードの初期値を追加し、このモードのLEDを処理するだけです。プログラムにはまだ十分な説明とコメントが必要で、すでに面倒に見えます。したがって、個別のメソッドでモードの処理を削除する決定が行われます。

 inline void SetLedsBeginState(tLedMode mode, tPort *leds) { switch (mode) { case LM_Tree: case LM_All: SwitchOnAllLed(leds, LEDS_COUNT); break; case LM_Chess: SwitchChessLed(leds, LEDS_COUNT); break; default: break; } } inline void UpdateLeds(tLedMode mode, tPort *leds, int curLed) { switch (mode) { case LM_Tree: ToggleLed(&leds[curLed]); break; case LM_All: case LM_Chess: ToggleAll(leds, LEDS_COUNT); break; default: break; } }

この場合、メインプログラムはより良く見えます。

 int main(void) { tPort Leds[] = { {GPIOC, 5U},{GPIOC, 8U},{GPIOC, 9U},{GPIOA, 5U} }; tPort Button = {GPIOC, BUTTON_PIN}; tLedMode Mode = LM_Tree; int currentLed = 0; SwitchOnAllLed(Leds, LEDS_COUNT); for (;;) { //   .    1,    0 if (!CHECK_BIT(Button.pPort->IDR, BUTTON_PIN)) { //   Mode = (Mode < LM_End) ? (tLedMode)(Mode + 1U) : LM_Tree; currentLed = 0; //      SetLedsBeginState(Mode, Leds); } //      UpdateLeds(Mode, Leds, currentLed); currentLed = (currentLed < (LEDS_COUNT -1)) ? (currentLed + 1) : 0; Delay(300U); } return 0; }

しかし、それでも人間のようなものが欲しい

 If Button is Pressed then set Next Light Mode Update Leds Delay 1000ms

これをCで実行することもできますが、関数の外部にあるいくつかの変数（currentLed、Modeなど）を保持する必要があります。これらの変数は、関数がそれらについて認識できるようにグローバルでなければなりません。そして、私たちが知っているように、グローバル変数は再び潜在的なエラーのリスクです。モジュールの1つでグローバル変数の値を不注意に変更することができます。これは、それがどこでどのように変化するかをすべて覚えておくことができず、1年後にそれがなぜ必要なのかさえ覚えていないためです

構造体を使用してこのデータを保存し、CでOOPを使用しようとすることができますが、この場合、多くのオーバーヘッドがあり、少なくとも関数へのポインターを保存する必要があり、コードはC ++に非常に似ていることを理解する必要があります。

したがって、C ++のコードに直接進みます。

 int main() { LedsController leds; Button button{ *GPIOC, 13U }; for (;;) { if (button.IsPressed()) { leds.NextMode(); } else { leds.Update(); } Delay(1sec); } return 0; }

完全なコード

utils.hpp

 #ifndef UTILS_H #define UTILS_H #include <cassert> namespace utils { template<typename T, typename T1> inline void setBit(T &value, T1 bit) { assert((sizeof(T) * 8U) > bit); value |= static_cast<T>(static_cast<T>(1) << static_cast<T>(bit)); }; template<typename T, typename T1> inline void clearBit(T &value, T1 bit) { assert((sizeof(T) * 8U) > bit); value &=~ static_cast<T>(static_cast<T>(1) << static_cast<T>(bit)); }; template<typename T,typename T1> inline void toggleBit(T &value, T1 bit) { assert((sizeof(T) * 8U) > bit); value ^= static_cast<T>(static_cast<T>(1) << static_cast<T>(bit)); }; template<typename T, typename T1> inline bool checkBit(const T &value, T1 bit) { assert((sizeof(T) * 8U) > bit); return !((value & (static_cast<T>(1) << static_cast<T>(bit))) == static_cast<T>(0U)); }; }; constexpr unsigned long long operator "" sec(unsigned long long sec) { return sec * 1000U; } #endif

led.hpp

 #ifndef LED_H #define LED_H #include "utils.hpp" class Led { public: Led(GPIO_TypeDef &portName, unsigned int pinNum): port(portName), pin(pinNum) {}; inline void Toggle() const { utils::toggleBit(port.ODR, pin); } inline void SwitchOn() const { utils::setBit(port.ODR, pin); } inline void SwitchOff() const { utils::clearBit(port.ODR, pin); } private: GPIO_TypeDef &port; unsigned int pin; }; #endif

LedsController.hpp

 #ifndef LEDSCONTROLLER_H #define LEDSCONTROLLER_H #include "led.hpp" #include <array> enum class LedMode : unsigned char { Tree = 0, Chess = 1, All = 2, End = 2 }; constexpr int LedsCount = 4; class LedsController { public: LedsController() { SwitchOnAll(); }; void SwitchOnAll() { for (auto &led: leds) { led.SwitchOn(); } }; void ToggleAll() { for (auto &led: leds) { led.Toggle(); } }; void NextMode() { mode = (mode < LedMode::End) ? static_cast<LedMode>(static_cast<unsigned char>(mode) + 1U) : LedMode::Tree; currentLed = 0; if (mode == LedMode::Chess){ for(int i = 0; i < LedsCount; i++) { if ((i % 2) == 0) { leds[i].SwitchOn(); } else { leds[i].SwitchOff(); } } } else { SwitchOnAll(); } }; void Update() { switch(mode) { case LedMode::Tree: leds[currentLed].Toggle(); break; case LedMode::All: case LedMode::Chess: ToggleAll(); break; default: break; } currentLed = (currentLed < (LedsCount - 1)) ? (currentLed + 1) : 0; } private: LedMode mode = LedMode::Tree; int currentLed = 0; std::array<Led, LedsCount> leds{Led{*GPIOC, 5U},Led{*GPIOC, 8U},Led{*GPIOC, 9U},Led{*GPIOA, 5U}}; }; #endif

startup.cpp

 #pragma language = extended #pragma segment = "CSTACK" extern "C" void __iar_program_start( void ); class DummyModule { public: static void handler(); }; typedef void( *intfunc )( void ); //cstat !MISRAC++2008-9-5-1 typedef union { intfunc __fun; void * __ptr; } intvec_elem; #pragma location = ".intvec" //cstat !MISRAC++2008-0-1-4_b !MISRAC++2008-9-5-1 extern "C" const intvec_elem __vector_table[] = { { .__ptr = __sfe( "CSTACK" ) }, __iar_program_start, DummyModule::handler, DummyModule::handler, DummyModule::handler, DummyModule::handler, DummyModule::handler, 0, 0, 0, 0, DummyModule::handler, DummyModule::handler, 0, DummyModule::handler, DummyModule::handler, //External Interrupts DummyModule::handler, //Window Watchdog DummyModule::handler, //PVD through EXTI Line detect/EXTI16 DummyModule::handler, //Tamper and Time Stamp/EXTI21 DummyModule::handler, //RTC Wakeup/EXTI22 DummyModule::handler, //FLASH DummyModule::handler, //RCC DummyModule::handler, //EXTI Line 0 DummyModule::handler, //EXTI Line 1 DummyModule::handler, //EXTI Line 2 DummyModule::handler, //EXTI Line 3 DummyModule::handler, //EXTI Line 4 DummyModule::handler, //DMA1 Stream 0 DummyModule::handler, //DMA1 Stream 1 DummyModule::handler, //DMA1 Stream 2 DummyModule::handler, //DMA1 Stream 3 DummyModule::handler, //DMA1 Stream 4 DummyModule::handler, //DMA1 Stream 5 DummyModule::handler, //DMA1 Stream 6 DummyModule::handler, //ADC1 0, //USB High Priority 0, //USB Low Priority 0, //DAC 0, //COMP through EXTI Line DummyModule::handler, //EXTI Line 9..5 DummyModule::handler, //TIM9/TIM1 Break interrupt DummyModule::handler, //TIM10/TIM1 Update interrupt DummyModule::handler, //TIM11/TIM1 Trigger/Commutation interrupts DummyModule::handler, //TIM1 Capture Compare interrupt DummyModule::handler, //TIM2 DummyModule::handler, //TIM3 DummyModule::handler, //TIM4 DummyModule::handler, //I2C1 Event DummyModule::handler, //I2C1 Error DummyModule::handler, //I2C2 Event DummyModule::handler, //I2C2 Error DummyModule::handler, //SPI1 DummyModule::handler, //SPI2 DummyModule::handler, //USART1 DummyModule::handler, //USART2 0, DummyModule::handler, //EXTI Line 15..10 DummyModule::handler, //EXTI Line 17 interrupt / RTC Alarms (A and B) through EXTI line interrupt DummyModule::handler, //EXTI Line 18 interrupt / USB On-The-Go FS Wakeup through EXTI line interrupt 0, //TIM6 0, //TIM7 f0 0, 0, DummyModule::handler, //DMA1 Stream 7 global interrupt fc 0, DummyModule::handler, //SDIO global interrupt DummyModule::handler, //TIM5 global interrupt DummyModule::handler, //SPI3 global interrupt 0, // 110 0, 0, 0, DummyModule::handler, //DMA2 Stream0 global interrupt 120 DummyModule::handler, //DMA2 Stream1 global interrupt DummyModule::handler, //DMA2 Stream2 global interrupt DummyModule::handler, //DMA2 Stream3 global interrupt DummyModule::handler, //DMA2 Stream4 global interrupt 130 0, 0, 0, 0, 0, 0, DummyModule::handler, //USB On The Go FS global interrupt, 14C DummyModule::handler, //DMA2 Stream5 global interrupt DummyModule::handler, //DMA2 Stream6 global interrupt DummyModule::handler, //DMA2 Stream7 global interrupt DummyModule::handler, //USART6 15C DummyModule::handler, //I2C3 Event DummyModule::handler, //I2C3 Error 164 0, 0, 0, 0, 0, 0, 0, DummyModule::handler, //FPU 184 0, 0, DummyModule::handler, //SPI 4 global interrupt DummyModule::handler //SPI 5 global interrupt }; __weak void DummyModule::handler() { for(;;) {} }; extern "C" void __cmain( void ); extern "C" __weak void __iar_init_core( void ); extern "C" __weak void __iar_init_vfp( void ); #pragma required=__vector_table void __iar_program_start( void ) { __iar_init_core(); __iar_init_vfp(); __cmain(); }

main.cpp

 #include <stm32f411xe.h> #include "ledscontroller.hpp" #include "button.hpp" extern "C" { int __low_level_init(void) { //    16  RCC->CR |= RCC_CR_HSION; while ((RCC->CR & RCC_CR_HSIRDY) != RCC_CR_HSIRDY) { } //      RCC->CFGR |= RCC_CFGR_SW_HSI; while ((RCC->CFGR & RCC_CFGR_SWS) != RCC_CFGR_SWS_HSI) { } //       RCC->AHB1ENR |= (RCC_AHB1ENR_GPIOCEN | RCC_AHB1ENR_GPIOAEN); //LED1  PortA.5,  PortA.5   GPIOA->MODER |= GPIO_MODER_MODE5_0; //LED2  Port.9,LED3  PortC.8,LED4  PortC.5  PortC.5,8,9   GPIOC->MODER |= (GPIO_MODER_MODE5_0 | GPIO_MODER_MODE8_0 | GPIO_MODER_MODE9_0); return 1; } } //,       inline void Delay(unsigned int mSec) { for (unsigned int i = 0U; i < mSec * 3000U; i++) { __NOP(); }; } int main() { LedsController leds; LedsController leds1; Button buttonUser{*GPIOC, 13U}; for(;;) { if (buttonUser.IsPressed()) { leds.NextMode(); } else { leds.Update(); leds1.Update(); } Delay(1sec); } return 0; }

ほとんど人間の言語でC ++コードを書くことができたように見えますか？コードは非常に明確でシンプルですか？このコードにはコメントは必要ありません。すべてが明確です。ユーザーリテラル「sec」を使用して、これが1秒であることを明確にし、次の構成を使用して、遅延関数への送信用のサンプルに変換します。

 constexpr unsigned long long operator "" sec(unsigned long long sec) { return sec * 1000U; } ... Delay(1sec);

カスタムリテラルの定義は、 ""演算子とリテラルの名前を使用して指定されます。constexprキーワードは、可能であれば、コンパイル段階で値を計算し、コードに単純に代入する必要があることをコパイレーターに伝えます。この場合、すべての値は入力で既知であり、1を渡し、出力で1000を取得するため、コンパイラは単にDelay（1sec）呼び出しをDelay（1000）に置き換えます-非常に便利で読みやすいです。同じキーワードを使用して、すべてのタイプマクロを置き換えることができ、

 #define MAGIC_NUM 0x5f3759df

より理解しやすい

 constexpr unsigned int MagicNumber = 0x5f3759df;

繰り返しになりますが、非常に拡張可能で理解しやすいコードが得られました。LEDを点滅させるための新しいモードを追加したり、LEDの数を変更したりする場合、ここで何も変更する必要はありません。 LedsControllerクラスでのみ小さな変更を行う必要があります。これは、LEDの動作を担当します。このアプローチを使用する利点は明らかです。

それで、そのような解決策を現在採用しているリソースはいくつですか？コードを見ると、ほとんどすべてのプログラマーがC ++コードをもっと大きくすべきだと言うでしょうが、何があるのか、私自身もこれを確信しています。結局のところ、スタックにはいくつかのオブジェクトがあり、デザイナーへの呼び出しと追加のメソッドがあります。しかし、十分な仮定-数値に移り、最適化を無効にしてCとC ++のコードのサイズを比較してみましょう。Cコードは496バイトと80バイトの最大スタックネスティングをとります。 C ++コードは、606バイトと112バイトのスタックネストを使用します。

Cを優先して、コードとスタックサイズの面で20％の利点があるように見えます。ただし、デフォルトでは、IARコンパイラーは関数のインラインキーワードにまったく応答しないため、毎回関数呼び出しを挿入します。これにより、関数コンテキストの保存と復元によるコードとスタックの増加、および減少につながります。実行速度。これは、メソッドと関数を適切にデバッグできるようにするために行われます。そうしないと、結果のコードに一部の関数とローカル変数がまったく存在しなくなります。

インライン関数の最適化とサポートを有効にすると、状況は異なります。 Cコードは、スタックで396バイトと72バイトを使用します。

C ++コードはスタックで400バイトと72バイトを使用します。違いは4バイトで、アセンブラコードはCコードとほとんど同じですが、C ++コードの単純さと簡潔さにおいて明らかな利点があります。そして、C ++ではファームウェアを書くことは有益ではないと誰が言うでしょうか？

PS：

サンプルコードはこちらから入手できます。

見つかった欠陥をありがとうvanxant、マブ、EXCHG、Antervisを。kosmos89良いアドバイスとするためNightShad0w STDライブラリ使用して最小探索例えばSTDと検索コードnamenshegoを

助言にJef239次いで、LEDのアレイのためのメモリサイズを小さくする静的CONSTとして定義され、すべてのクラスは定数を作るための方法を導くことができる、プロセッサ上のアレイプログラムメモリに配置され、スタックはこの配列のサイズだけ減少します。選択は開発者次第ですが、これはより重要です...

マイクロコントローラーの小さなプロジェクトにCの代わりにC ++を使用することは可能ですか？

More articles: