步驟1：

1?？蚣埽何业目蚣苤皇菍蓚€鋁制伺服支架用螺栓固定到兩個垂直的膠合板上，并與伺服支架固定在一起?？蚣艿臉嫵苫蚺渲梅绞綄嶋H上并不重要。您可能應該將其調高一點，然后將電池放在頂部-多少錢總是一個問題，太高了，電動機將沒有足夠的扭矩來使車輪足夠快地旋轉，過低又可能使電動機太慢而無法轉動抓住機器人的傾斜。一塊水平的膠合板底部裝有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進行調整，所以這很酷。使用更多的輸入將很有趣，您可以簡單地將陀螺儀的值設置為兩個輸入，而將加速度計設置為三個輸入神經網絡的另一個。然后，您將不需要補充過濾器，因為神經網絡將充當過濾器。不確定如何操作，但嘗試可能很有趣。