步驟1：

1。框架：我的框架只是將兩個鋁制伺服支架用螺栓固定到兩個垂直的膠合板上，并與伺服支架固定在一起。框架的構成或配置方式實際上并不重要。您可能應該將其調高一點，然后將電池放在頂部-多少錢總是一個問題，太高了，電動機將沒有足夠的扭矩來使車輪足夠快地旋轉，過低又可能使電動機太慢而無法轉動抓住機器人的傾斜。一塊水平的膠合板底部裝有Arduino Uno和電機控制器。

2。馬達：我使用了兩個無處不在的黃色齒輪馬達和車輪，每個到處都可以找到，價格分別為幾美元。它們的轉速約為110 rpm，足以平衡，但如果轉速約為200或300 rpm，那就太好了。它們的齒輪傾斜度很小，因此機器人總是會有點擺動。在將它們連接到電機控制器之前，您可能應該將兩個電機引線互相纏繞，以防止雜散電磁場干擾Arduino。在電動機引線兩端連接幾個電容器也是一個好主意。我用幾個拉鏈把電動機固定在車架上，效果很好。

3。馬達控制器：我使用了L293D迷你控制器，我非常喜歡它，因為我可以使用一個2s鋰電池為控制器供電，該控制器還可以為Arduino Uno供電-無需第二個電池。輕巧的重量減輕器和輕巧的重量，意味著機器人更容易平衡。

4。 MPU6050陀螺儀/加速度計：這是一個不錯的小模塊，用于測量機器人的傾斜角度。調用函數非常簡單。我將我的機器人安裝在arduino和機器人的傾斜軸上方。有些人說應該更高些，有些人說應該更低些，但是可以找到它在哪里。

5。 Arduino Uno：神經網絡將輕松以2k運行。

6。電源開關：連接電源開關以打開和關閉電池真的很值得。使機器人的使用變得比每次都要插入電池更容易。

7。 LIPO電池：我使用800mah 2s電池為所有電池供電。電池壽命通常約為連續運行20分鐘或更長時間。足夠用于測試和玩耍。

8。原理圖：最后一張照片是我連接所有模塊和電機的示意圖。

步驟2：加載并運行Arduino草圖

1。 MPU6050校準：在實際運行機器人之前，首先需要進行的是陀螺儀/加速度計的校準。下載位于以下位置的校準草圖：http：//forum.arduino.cc/index.php？action = dlattach; 。..在執行之前，將您的機器人筆直站立，并在校準程序運行時不要移動它。除非您碰巧將MPU6050移動到機器人上的新位置，否則您只需運行一次校準例程。

運行時，它將向Arduino串行監視器輸出6個值需要三個才能放入草圖。

2。 NeuralNet-SelfBalancingRobot草圖：將以下草圖加載到Arduino Uno。您需要將GYRO/ACC參數更改為校準運行中的參數。然后運行草圖，查看機器人是否平衡。我的機器人會在地毯或床上保持相當不錯的平衡，但會四處運行，然后掉落在光滑的地板上。

我為我的機器人設置了PID代碼，其平衡與Neuro Net略有不同但是使用NN基本上沒有調整，只需加載草圖即可平衡。 PID例程需要大量的操作。

我可以將我的PID控制器上傳到SB機器人，而無需進行任何修改即可比較PID與NN軟件。 NN會在平衡點附近以較小的振蕩獲勝，但會在受到干擾的情況下輸給PID。但是我還沒有真正調整NN。

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//神經網絡程序，使用S型函數并應用于簡單的自平衡機器人

//由商洛大學Jim Demello創建，2018年5月

//改編自Sean Hodgins神經網絡代碼：https：//www.instructables.com/id/Arduino-Neural-Ne。

/修改了midhun_s自平衡機器人代碼：https://www.instructables.com/id/Arduino-Self-Bala.。.

/構建了我自己的自平衡機器人

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include“ MPU6050.h”

＃包括“ math.h”

/**************************************** **********************************

網絡配置-為每個網絡自定義

************************************************** ****************/

const int PatternCount = 2;

const int InputNodes = 1;

const int Hidd enNodes = 3;

const int OutputNodes = 1;

const float LearningRate = 0.3;

const float Momentum = 0.9;

const float InitialWeightMax = 0.5;

const float Success = 0.0015;

float Input ［PatternCount］ ［InputNodes］ = {

{0}，//左傾斜

{1}//傾斜

//{-1}//傾斜

//{0，1，1，0} ，//左右左右發光

//{0，1，0，0}，//左右左右發光

//{1，1，1，0} ，//頂部，左側和右側的燈光

}；

const float Target ［PatternCount］ ［OutputNodes］ = {

{0，}，////左傾斜

{1，}//右傾斜

//{-1，}//左移動

//{0.65， 0.55}，//LEFT MOTOR SLOW

//{0.75，0.5}，//LEFT MOTOR FASTER

};

/***** ************************************************** ***********

終端網絡配置

********************** ***************/

int i，j，p，q，r;

int ReportEvery1000;

int RandomizedIndex ［PatternC ount］;

長時間訓練周期；

浮動Rando；

浮動誤差= 2；

浮動累積；

float Hidden ［HiddenNodes］;

float Output ［OutputNodes］;

float HiddenWeights ［InputNodes + 1］ ［HiddenNodes］;

float OutputWeights ［HiddenNodes + 1］ ［OutputNodes］;

float HiddenDelta ［HiddenNodes］;

float OutputDelta ［OutputNodes］;

float ChangeHiddenWeights ［InputNodes + 1］ ［HiddenNodes］ ;

float ChangeOutputWeights ［HiddenNodes +1］ ［OutputNodes］;

#define leftMotorPWMPin 6

#define leftMotorDirPin 7

#define rightMotorPWMPin 5

#define rightMotorDirPin 4

#define sampleTime 0.005

MPU6050 mpu;

int16_t accY，accZ，gyroX;

int motorPower，gyroRate;

float accAngle，gyroAngle，currentAngle，prevAngle = 0，error，prevError = 0，errorSum = 0;

字節數= 0;

long previousMillis = 0;

unsigned long currentMillis;

long loopTimer = 4;

void setMotors（int leftMotorSpeed，int rightMotorSpeed）{

//串行.print（“ leftMotorSpeed =”）; Serial.print（leftMotorSpeed）; Serial.print（“ rightMotorSpeed =”）; Serial.println（rightMotorSpeed）;

if（leftMotorSpeed》 = 0）{

AnalogWrite（leftMotorPWMPin，leftMotorSpeed）;

digitalWrite（leftMotorDirPin，LOW）;

}

else {//如果leftMotorSpeed為《0，則將dir設置為反向

AnalogWrite（leftMotorPWMPin， 255 + leftMotorSpeed）;

digitalWrite（leftMotorDirPin，HIGH）;

}

if（rightMotorSpeed》 = 0）{

AnalogWrite （rightMotorPWMPin，rightMotorSpeed）;

digitalWrite（rightMotorDirPin，LOW）;

}

else {

AnalogWrite（rightMotorPWMPin，255 + rightMotorSpeed）;

digitalWrite（rightMotorDirPin，HIGH）;

}

}

void setup（）{

Serial.begin（115200）;

Serial.println（“啟動程序”）;

randomSeed（analogRead（A1））;//收集一個隨機ADC樣本以進行隨機化。

ReportEvery1000 = 1;

for（p = 0; p

RandomizedIndex ［ p］ = p;

}

Serial.println（“ do train_nn”）;

train_nn（）;

delay（ 1000）;

//將電動機控制和PWM引腳設置為輸出模式

pinMode（leftMotorPWMPin，OUTPUT）;

pinMode（leftMotorDirPin，OUTPUT）;

pinMode（rightMotorPWMPin，OUTPUT）;

pinMode（rightMotorDirPin，OUTPUT）;

//初始化MPU6050并設置偏移值

mpu.initialize（）;

mpu.setYAccelOffset（2113）;//通過校準例程

mpu.setZAccelOffset（1122）;

mpu.setXGyroOffset（7）;

Serial.print（“ End在以下位置初始化MPU： “）; Serial.println（米利斯（））;

}

///////////////

/主循環/

/////////////

void loop（）{

drive_nn（）;

}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////

/使用了訓練有素的神經網絡要驅動機器人

void drive_nn（）

{

Serial.println（“ Running NN Drive”）;

while（Error 《成功）{

currentMillis = millis（）;

float TestInput ［］ = {0，0};

if（currentMillis-previousMillis》 loopTimer） {//每5毫秒或更長時間進行一次計算

Serial.print（“ currentMillis =”）; Serial.println（currentMillis）;

/////////////////////////////////////

//計算incli的角度國家//

//////////////////////////////////////////

accY = mpu.getAccelerationY（）;

accZ = mpu.getAccelerationZ（）;

gyroX = mpu.getRotationX（）;

accAngle = atan2（accY，accZ）* RAD_TO_DEG;

gyroRate = map（gyroX，-32768，32767 ，-250，250）;

gyroAngle =（float）gyroRate * sampleTime;

///////////////////////////////////////////////////////////////////

//補充過濾器///////////////////////////////////////////

////////////////////////////////////////////////////////////////////

currentAngle = 0.9934 *（prevAngle + gyroAngle）+ 0.0066 *（accAngle）;

//Serial.print（“currentAngle=“）; Serial.print（currentAngle）; Serial.print（“ error =”）; Serial.println（error）;

//錯誤= currentAngle-targetAngle;//不使用

float nnInput = currentAngle;

//Serial.print（“ nnInput =”）; Serial.println（nnInput）;

nnInput = map（nnInput，-30，30，0，100）;//將傾斜角度范圍映射到0到100

TestInput ［0］ = float（nnInput）/100;//轉換為0到1

//Serial.print（“ testinput =”）; Serial.println（TestInput ［0］）;

InputToOutput（TestInput ［0］） ;//輸入到ANN以獲取輸出

//Serial.print（”output =“）; Serial.println（Output ［0］）;

///////////////////////////////////////////

//在之后設置電動機功率約束它//

///////////////////////////////////////////

motorPower =輸出［0］ * 100；//從0轉換為1

//如果（motorPower 《50）motorPower = motorPower * -1;

motorPower = map（motorPower，0，100，-300，300 ）;

motorPower = motorPower +（motorPower * 6.0）;//需要乘數以使車輪在接近平衡點時足夠快地旋轉

//Serial.print（“motorPower =“）; Serial.println（motorPower）;

motorPower = constrain（motorPower，-255，255）;

prevAngle = currentAngle;

previousMillis = currentMillis;

}//結束毫秒循環

//如果（abs（error）》 30）motorPower = 0;//如果跌落則關閉電動機

//motorPower = motorPower + error;

setMotors（motorPower，motorPower）;

}

}//drive_nn（）函數的結尾

///在培訓時顯示信息

無效到Terminal（）

{

for（p = 0; p

Serial.println（）;

Serial.print（“ Training Pattern：”）;

Serial.println（p）;

Serial.print（“ Input”）;

for（i = 0; i

Serial.print（Input ［p］ ［i］，DEC）;

Serial.print（“”）;

}

Serial.print （“ Target”）;

for（i = 0; i

Serial.print（Target ［p］ ［i］，DEC）;

Serial.print（“”）;

}

/********************* **************

計算隱藏層激活

***************************************** *********************************/

for（i = 0; i

Accum = HiddenWeights ［InputNodes］ ［i］；

for（j = 0; j

累計+ =輸入［p］ ［j］ * HiddenWeights ［j］ ［i］;

}

隱藏［i］ = 1.0/（1.0 + exp（-Accum））;//激活功能

}

/****************************** ******************************************

計算輸出層激活并計算錯誤

******************************************* ***************************/

用于（i = 0; i

累計= OutputWeights ［HiddenNodes］ ［i］;

for（j = 0; j 《隱藏節點; j ++）{

累計+ =隱藏［j］ * OutputWeights ［j］ ［i］;

}

輸出［i］ = 1.0/（1.0 + exp（-Accum））;

}

Serial.print（“ Output”）;

for（i = 0; i

Serial.print（Output ［i］，5）;

Serial.print（“”）;

}

}

}

無效InputToOutput（float In1 ）

{

float TestInput ［］ = {0};

TestInput ［0］ = In1;

//TestInput ［ 1］ = In2；//未使用

//TestInput ［2］ = In3;//未使用

//TestInput ［3］ = In4;//不使用

/****************************************** ****************************

計算隱藏層激活

**** ************************************************** ************/

for（i = 0; i

Accum = HiddenWeights ［InputNodes］ ［i］;

for（j = 0; j

累計+ = TestInput ［j］ * HiddenWeights ［j］ ［i］;

}

隱藏［i］ = 1.0/（1.0 + exp（-Accum））;

}

/********* ************************************************** *******

計算輸出層激活并計算錯誤

********************** ***************/

for（i = 0; i

Accum = OutputWeights ［HiddenNodes］ ［i］;

for（j = 0; j

累計+ =隱藏［j］ * OutputWeights ［j］ ［i］;

}

輸出［i］ = 1.0/（1.0 + exp（-Accum））;

}

//＃ifdef調試

Serial.print（“輸出”）；

對于（i = 0 ;我

Serial.print（Output ［i］，5）;

Serial.print（“”）;

}

//＃endif

}

//訓練神經網絡

void train_nn（）{

/*** ************************************************** *************

初始化HiddenWeights和ChangeHiddenWeights

******************* ***************/

int prog_start = 0;

Serial.println（“開始培訓。..”）;

//digitalWrite（LEDYEL，LOW）;

for（i = 0; i

for（j = 0; j 《= InputNodes; j ++）{

ChangeHiddenWeights ［j］ ［i ］ = 0.0;

Rando = float（random（100））/100;

HiddenWeights ［j］ ［i］ = 2.0 *（Rando-0.5）* InitialWeightMax;

}

}

//digitalWrite（LEDYEL，HIGH）;

/************ ************************************************** ****

初始化OutputWeights和ChangeOutputWeights

**************************** ******************************************/

//digitalW rite（LEDRED，LOW）;

for（i = 0;我

for（j = 0; j 《= HiddenNodes; j ++）{

ChangeOutputWeights ［j］ ［i］ = 0.0;

Rando = float（random（100））/100;

OutputWeights ［j］ ［i］ = 2.0 *（Rando-0.5）* InitialWeightMax;

}

}

//digitalWrite（LEDRED，HIGH）;

//SerialUSB.println（”Initial/Untrained Outputs：“）;

//toTerminal（）;

/****************************************** ****************************

開始訓練

****** ************************************************** **********/

用于（TrainingCycle = 1; TrainingCycle 《2147483647; TrainingCycle ++）{

/*********** ************************************************** *****

隨機分配訓練模式的順序

************************** ********************************************/

用于（ p = 0; p

q = random（PatternCount）;

r = RandomizedIndex ［p］;

RandomizedIndex ［p］ = RandomizedIndex ［q］;

RandomizedIndex ［q］ = r;

}

錯誤= 0.0;

/*************************************** **************************************

以隨機順序遍歷每種訓練模式

》

************************************************** ********************/

為（q = 0; q

p = RandomizedIndex ［q］;

/************************* **********************************************

隱藏計算層激活

********************************************* *****************************/

//digitalWrite（LEDYEL，LOW）;

表示（i = 0; i

累計= HiddenWeights ［InputNodes］ ［i］;

for（j = 0; j

累計+ =輸入［p］ ［j］ *隱藏重量［j］ ［i］；

}

隱藏［i］ = 1.0/（1.0 + exp（-Accum））;

}

//digitalWrite（LEDYEL，HIGH）;

/*********** ************************************************** *****

計算輸出層激活并計算錯誤

************************ *************/

//digitalWrite（LEDRED，LOW）;

for（i = 0; i

Accum = OutputWeights ［HiddenNodes］ ［i］;

for（j = 0; j

累計+ =隱藏［j］ * OutputWeights ［j］ ［i］;

}

Output ［i］ = 1.0/（1.0 + exp（-Accum））;

OutputDelta ［i］ =（Target ［p］ ［i］-Output ［ i］）*輸出［i］ *（1.0-輸出［i］）;

錯誤+ = 0.5 *（目標［p］ ［i］-輸出［i］）*（目標［p］ ［i］-Output ［i］）;

}

//Serial.println（Output ［0］ * 100）;

//digitalWrite（ LEDRED，HIGH）;

/***************************************** *********************************

向后傳播到隱藏層的錯誤

** ************************************************** **************/

//digitalWrite（LEDYEL，LOW）;

for（i = 0;我

累計= 0.0;

對于（j = 0; j

累計+ = OutputWeights ［i］ ［j ］ * OutputDelta ［j］;

}

HiddenDelta ［i］ =累積*隱藏［i］ *（1.0-隱藏［i］）;

}

//digitalWrite（LEDYEL，HIGH）;

/************************* **********************************************

更新內部-》隱藏重量

****************************************** ********************************/

//digitalWrite（LEDRED，LOW）;

for（i = 0; i

ChangeHiddenWeights ［InputNodes］ ［i］ = LearningRate * HiddenDelta ［i］ +動量* ChangeHiddenWeights ［InputNodes］ ［i］;

HiddenWeights ［InputNodes］ ［i］ + = ChangeHiddenWeights ［InputNodes］ ［i］;

for（j = 0; j

ChangeHiddenWeights ［ j］ ［i］ =學習率*輸入［p］ ［j］ * HiddenDelta ［i］ +動量* ChangeHiddenWeights ［j］ ［i］;

HiddenWeights ［j］ ［i］ + = ChangeHiddenWeights ［j ］ ［i］;

}

}

//digitalWrite（LEDRED，HIGH）;

/************************************************* *********************

隱藏更新-》輸出權重

******** ************************************************** ********/

//digitalWrite（LEDYEL，LOW）;

for（i = 0;我

ChangeOutputWeights ［HiddenNodes］ ［i］ =學習率* OutputDelta ［i］ +動量* ChangeOutputWeights ［HiddenNodes］ ［i］;

OutputWeights ［HiddenNodes］ ［i］ ］ + = ChangeOutputWeights ［HiddenNodes］ ［i］;

for（j = 0; j

ChangeOutputWeights ［j］ ［i］ = LearningRate * Hidden ［ j］ * OutputDelta ［i］ +動量* ChangeOutputWeights ［j］ ［i］;

OutputWeights ［j］ ［i］ + = ChangeOutputWeights ［j］ ［i］;

}

}

//digitalWrite（LEDYEL，HIGH）;

}

/********** ************************************************** ******

每100個周期將數據發送到終端進行顯示并在OLED上繪制圖形

*************** ************************************************** */

ReportEvery1000 = ReportEvery1000-1;

如果（ReportEvery1000 == 0）

{

int graphNum = TrainingCycle/100 ;

int graphE1 =錯誤* 1000;

int graphE = map（graphE1，3，80，47，0）;

Serial.print（“ TrainingCycle：“）;

Se rial.print（TrainingCycle）;

Serial.print（“ Error =”）;

Serial.println（Error，5）;

toTerminal（） ;

if（TrainingCycle == 1）

{

ReportEvery1000 = 99;

}

否則

{

ReportEvery1000 = 100;

}

}

/******* ************************************************** *********

如果錯誤率小于預定閾值，則結束

*************** ************************************************** */

如果（錯誤《成功）中斷;

}

}

步驟3：最終注釋

1。這些參數可能只需要一點點就可以播放，尤其是可以增加NN輸出值的乘法器。當電動機接近平衡時，必須使用該倍增器來提高電動機的轉速。事實證明，這幾乎迫使機器人成為爆炸式，平衡式機器人。如果在平衡點附近的電動機的值不夠高，則機器人將在電動機具有足夠的rpm來捕捉下降之前倒下。

2。也許可以使用比S形函數更好的激活函數。有人說tanf函數更有用。我認為真正需要的只是一個簡單的f（x）函數。對這個領域的任何人都會真正感興趣。

3。這是一個簡單的單輸入，多個隱藏節點和單個輸出神經網絡，而且肯定會產生過大的殺傷力，因為PID控制器會更簡單，并且您實際上可以使用僅一行代碼的簡單P控制器來達到平衡。但是，我不必像PID控制器那樣對這個NN進行調整，所以這很酷。使用更多的輸入將很有趣，您可以簡單地將陀螺儀的值設置為兩個輸入，而將加速度計設置為三個輸入神經網絡的另一個。然后，您將不需要補充過濾器，因為神經網絡將充當過濾器。不確定如何操作，但嘗試可能很有趣。