Baldroid v3 Balancing Robot met Actobotics onderdelen en IOIO-OTG (12 / 12 stap)

Stap 12: Main code...


Hier is de belangrijkste code... Ik kan een ZIP-bestand met het gehele project van Java op verzoek sturen... Stuur de aanvraag naar joebotics

MAIN CODE:

pakket ioio.examples.simple;

BALANS ACT 4 + MOGA 2

importeren van ioio.lib.api.PwmOutput;

importeren van ioio.lib.api.exception.ConnectionLostException;

importeren van ioio.lib.util.BaseIOIOLooper;

importeren van ioio.lib.util.IOIOLooper;

importeren van ioio.lib.util.android.IOIOActivity;

importeren van android.os.Bundle;

importeren van android.widget.TextView;

importeren van android.hardware.Sensor;

importeren van android.hardware.SensorEvent;

importeren van android.hardware.SensorEventListener;

importeren van android.hardware.SensorManager;

importeren van android.widget.SeekBar;

importeren van com.bda.controller.Controller;

importeren van com.bda.controller.ControllerListener;

importeren van com.bda.controller.KeyEvent;

importeren van com.bda.controller.MotionEvent;

importeren van com.bda.controller.StateEvent;

openbare klasse die ioiosimpleapp IOIOActivity breidt implementeert SensorEventListener {}

privé SensorManager mSensorManager;

privé Sensor mRotVectSensor;

privé float [] orientationVals = nieuwe float [3];

privé float [] mRotationMatrix = nieuwe float [16];

privé TextView textView_Current_Angle;

privé TextView textView_Tilt_adjuster;

privé TextView textView_kP_adjuster;

privé TextView textView_kI_adjuster;

privé TextView textView_kD_adjuster;

privé SeekBar seekBar_Tilt_adjuster;

privé SeekBar seekBar_kP_adjuster;

privé SeekBar seekBar_kI_adjuster;

privé SeekBar seekBar_kD_adjuster;

Controller mController = null;

definitieve ExampleControllerListener mListener = nieuwe ExampleControllerListener();

definitieve ExamplePlayer mPlayer = nieuwe ExamplePlayer (0.0f, 1.0f, 0.0f);

openbare nietige onCreate (bundel savedInstanceState) {}

mController = Controller.getInstance(this);

mController.init();

mController.setListener (mListener, null);

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

mSensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);

mRotVectSensor=mSensorManager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR);

textView_Current_Angle = (TextView) findViewById(R.id.TextView_CurrentAngle_Value);

textView_Tilt_adjuster = (TextView) findViewById(R.id.TextView_Tilt_adjusterValue);

seekBar_Tilt_adjuster = (SeekBar) findViewById(R.id.SeekBar_Tilt_adjuster);

textView_kP_adjuster = (TextView) findViewById(R.id.TextView_kP_adjusterValue);

seekBar_kP_adjuster = (SeekBar) findViewById(R.id.SeekBar_kP_adjuster);

textView_kI_adjuster = (TextView) findViewById(R.id.TextView_kI_adjusterValue);

seekBar_kI_adjuster = (SeekBar) findViewById(R.id.SeekBar_kI_adjuster);

textView_kD_adjuster = (TextView) findViewById(R.id.TextView_kD_adjusterValue);

seekBar_kD_adjuster = (SeekBar) findViewById(R.id.SeekBar_kD_adjuster);

seekBar_Tilt_adjuster.setProgress(500);

seekBar_kP_adjuster.setProgress(0);

seekBar_kI_adjuster.setProgress(0);

seekBar_kD_adjuster.setProgress(0);

enableUi(false);

}

openbare klasse ExampleControllerListener implementeert ControllerListener {}

openbare nietige onKeyEvent (KeyEvent evenement) {}

schakelaar (event.getKeyCode()) {}

Case KeyEvent.KEYCODE_BUTTON_X:

seekBar_Tilt_adjuster.setProgress(seekBar_Tilt_adjuster.getProgress() - 2);

breken;

Case KeyEvent.KEYCODE_BUTTON_B:

seekBar_Tilt_adjuster.setProgress(seekBar_Tilt_adjuster.getProgress() + 2);

breken;

Case KeyEvent.KEYCODE_BUTTON_Y:

seekBar_kP_adjuster.setProgress(seekBar_kP_adjuster.getProgress() + 2);

breken;

Case KeyEvent.KEYCODE_BUTTON_A:

seekBar_kP_adjuster.setProgress(seekBar_kP_adjuster.getProgress() - 2);

breken;

Case KeyEvent.KEYCODE_DPAD_UP:

seekBar_kI_adjuster.setProgress(seekBar_kI_adjuster.getProgress() + 2);

breken;

Case KeyEvent.KEYCODE_DPAD_DOWN:

seekBar_kI_adjuster.setProgress(seekBar_kI_adjuster.getProgress() - 2);

breken;

Case KeyEvent.KEYCODE_DPAD_RIGHT:

seekBar_kD_adjuster.setProgress(seekBar_kD_adjuster.getProgress() + 2);

breken;

Case KeyEvent.KEYCODE_DPAD_LEFT:

seekBar_kD_adjuster.setProgress(seekBar_kD_adjuster.getProgress() - 2);

breken;

}

}

openbare nietige onMotionEvent (MotionEvent evenement) {}

mPlayer.mAxisX = event.getAxisValue(MotionEvent.AXIS_X);

mPlayer.mAxisY = event.getAxisValue(MotionEvent.AXIS_Y);

mPlayer.mAxisZ = event.getAxisValue(MotionEvent.AXIS_Z);

mPlayer.mAxisRZ = event.getAxisValue(MotionEvent.AXIS_RZ);

}

openbare nietige onStateEvent (StateEvent evenement) {}

schakelaar (event.getState()) {}

Case StateEvent.STATE_CONNECTION:

mPlayer.mConnection = event.getAction();

breken;

}

}

}

openbare klasse ExamplePlayer {}

statische definitieve float DEFAULT_SCALE = 4.0f;

statische definitieve float DEFAULT_X = 0.0f;

statische definitieve float DEFAULT_Y = 0.0f;

Boole gotPadVersion = false;

public int, mConnection = StateEvent.ACTION_DISCONNECTED;

public int mControllerVersion = StateEvent.STATE_UNKNOWN;

public int mButtonA = KeyEvent.ACTION_UP;

public int mButtonB = KeyEvent.ACTION_UP;

public int mButtonX = KeyEvent.ACTION_UP;

public int mButtonY = KeyEvent.ACTION_UP;

public int DpadUp = KeyEvent.ACTION_UP;

public int DpadDown = KeyEvent.ACTION_UP;

public int DpadLeft = KeyEvent.ACTION_UP;

public int DpadRight = KeyEvent.ACTION_UP;

openbare float mAxisX = 0.0f;

openbare float mAxisY = 0.0f;

openbare float mAxisZ = 0.0f;

openbare float mAxisRZ = 0.0f;

definitieve zweven heer;

definitieve float mG;

definitieve float mB;

zweven mScale = DEFAULT_SCALE;

zweven mX = DEFAULT_X;

float mijn = DEFAULT_Y;

openbare ExamplePlayer (drijven van r, g, zweven zweven b) {}

Mijnheer = r;

mG = g;

mB = b;

}

}

openbare klasse Looper breidt BaseIOIOLooper {}

privé PwmOutput LeftWheel;

privé PwmOutput RightWheel;

privé PwmOutput LeftArm;

privé PwmOutput RightArm;

private int currentAngle;

private int previousAngle;

private int P = 0;

private int I = 0;

private int D = 0;

private int PID = 0;

private int D_delta;

private int I_delta;

public int seekbar_tilt_adjuster_value = 500;

private int seekbar_kP_adjuster_value = 0;

private int seekbar_kI_adjuster_value = 0;

private int seekbar_kD_adjuster_value = 0;

public void setup gooit ConnectionLostException {}

LeftArm = ioio_.openPwmOutput (13, 50);

RightArm = ioio_.openPwmOutput (12, 50);

LeftWheel = ioio_.openPwmOutput (10, 100);

RightWheel = ioio_.openPwmOutput (11, 100);

enableUi(true);

}

public void loop gooit ConnectionLostException, {InterruptedException}

seekbar_tilt_adjuster_value = seekBar_Tilt_adjuster.getProgress() - 500;

seekbar_kP_adjuster_value = seekBar_kP_adjuster.getProgress();

seekbar_kI_adjuster_value = seekBar_kI_adjuster.getProgress();

seekbar_kD_adjuster_value = seekBar_kD_adjuster.getProgress();

currentAngle = (Math.round (orientationVals [1] * 100)) + seekbar_tilt_adjuster_value - Math.round(mPlayer.mAxisY*10) - Math.round(mPlayer.mAxisRZ*10);

currentAngle = (Math.round (orientationVals [1] * 100)) + seekbar_tilt_adjuster_value;

D_delta = currentAngle - previousAngle;

I_delta = I_delta + D_delta;

P = (seekbar_kP_adjuster_value * currentAngle) / 2000;

Ik = (seekbar_kI_adjuster_value * I_delta) / 4000;

D = (seekbar_kD_adjuster_value * D_delta) / 4000;

Als (ik <-100) {}

Ik =-100;

} else if (ik > 100) {}

Ik = 100;

// }

PID = P + I + D;

previousAngle = currentAngle;

RightArm.setPulseWidth (1590 - Math.round(mPlayer.mAxisY*900));

LeftArm.setPulseWidth (1540 + Math.round(mPlayer.mAxisRZ*900));

RightWheel.setPulseWidth (1500 + Math.round(mPlayer.mAxisY*35) + PID);

LeftWheel.setPulseWidth (1502 - Math.round(mPlayer.mAxisRZ*35) - PID);

LeftWheel.setPulseWidth (1502 - PID);

RightWheel.setPulseWidth(1500 + PID);

setText_current_angle(Integer.toString(currentAngle));

setText_tilt_adjuster(Integer.toString(seekbar_tilt_adjuster_value));

setText_kP_adjuster(Integer.toString(seekbar_kP_adjuster_value));

setText_kI_adjuster(Integer.toString(seekbar_kI_adjuster_value));

setText_kD_adjuster(Integer.toString(seekbar_kD_adjuster_value));

setText_current_angle(Integer.toString(currentAngle));

setText_tilt_adjuster(Integer.toString(PID));

setText_kP_adjuster(Integer.toString(P));

setText_kI_adjuster(Integer.toString(I));

setText_kD_adjuster(Integer.toString(D));

}

openbare nietige disconnected() {}

enableUi(false);

}

}

beschermde IOIOLooper createIOIOLooper() {}

retourneren van nieuwe Looper();

}

private void enableUi (laatste Booleaanse inschakelen) {}

runOnUiThread (nieuwe Runnable() {}

openbare nietige run() {}

}

});

}

private void setText_current_angle (laatste String str) {}

runOnUiThread (nieuwe Runnable() {}

openbare nietige run() {}

textView_Current_Angle.setText(str);

}

});

}

private void setText_tilt_adjuster (laatste String str) {}

runOnUiThread (nieuwe Runnable() {}

openbare nietige run() {}

textView_Tilt_adjuster.setText(str);

}

});

}

private void setText_kP_adjuster (laatste String str) {}

runOnUiThread (nieuwe Runnable() {}

openbare nietige run() {}

textView_kP_adjuster.setText(str);

}

});

}

private void setText_kI_adjuster (laatste String str) {}

runOnUiThread (nieuwe Runnable() {}

openbare nietige run() {}

textView_kI_adjuster.setText(str);

}

});

}

private void setText_kD_adjuster (laatste String str) {}

runOnUiThread (nieuwe Runnable() {}

openbare nietige run() {}

textView_kD_adjuster.setText(str);

}

});

}

openbare nietige onSensorChanged (SensorEvent evenement)

{

if(Event.sensor.GetType()==sensor.TYPE_ROTATION_VECTOR)

{

SensorManager.getRotationMatrixFromVector(mRotationMatrix,event.values);

SensorManager.remapCoordinateSystem (mRotationMatrix,SensorManager.AXIS_X, SensorManager.AXIS_Z, mRotationMatrix);

SensorManager.getOrientation (mRotationMatrix, orientationVals);

orientationVals[1]=(float)Math.toDegrees(orientationVals[1]);

seekBar_kD_adjuster.setProgress(Math.round((orientationVals[1]*4)+500));

}

}

openbare nietige onAccuracyChanged (Sensor sensor, int nauwkeurigheid) {}

}

beschermd nietig onResume() {}

super.onResume();

deze klasse registreren als een listener voor de oriëntatie en

versnellingsmeter sensoren

mSensorManager.registerListener (dit,

mRotVectSensor,

10000);

mController.onResume();

mPlayer.mConnection = mController.getState(Controller.STATE_CONNECTION);

mPlayer.mControllerVersion = mController.getState(Controller.STATE_CURRENT_PRODUCT_VERSION); Controller-versie krijgen

mPlayer.mButtonA = mController.getKeyCode(Controller.KEYCODE_BUTTON_A);

mPlayer.mButtonB = mController.getKeyCode(Controller.KEYCODE_BUTTON_B);

mPlayer.mButtonX = mController.getKeyCode(Controller.KEYCODE_BUTTON_X);

mPlayer.mButtonY = mController.getKeyCode(Controller.KEYCODE_BUTTON_Y);

mPlayer.DpadUp = mController.getKeyCode(Controller.KEYCODE_DPAD_UP);

mPlayer.DpadDown = mController.getKeyCode(Controller.KEYCODE_DPAD_DOWN);

mPlayer.DpadLeft = mController.getKeyCode(Controller.KEYCODE_DPAD_LEFT);

mPlayer.DpadRight = mController.getKeyCode(Controller.KEYCODE_DPAD_RIGHT);

mPlayer.mAxisY = mController.getAxisValue(Controller.AXIS_Y);

mPlayer.mAxisRZ = mController.getAxisValue(Controller.AXIS_RZ);

}

beschermd nietig onPause() {}

Unregister luisteraar

super.onPause();

mSensorManager.unregisterListener(this);

mController.onPause();

}

beschermd nietig onDestroy() {}

mController.exit();

super.onDestroy();

}

}

// ----------------- ROBOT DIAGRAM ----------------------------- //

//

// _________

// | Front |

// | Geconfronteerd met |

// | Telefoon |

// ----------

// | |

// =========

LeftArm = 13 || ===| |===|| RightArm = 12

// || ===| |===||

// || | | ||

// || | | ||

// | |

// | |

// || | | ||

LeftWheel = 10 || =============|| RightWheel = 11

// || ||

//

//

Gerelateerde Artikelen

2-wiel Self Balancing Robot met behulp van de Arduino en MPU6050

2-wiel Self Balancing Robot met behulp van de Arduino en MPU6050

2-wiel Self Balancing Robot met behulp van de Arduino en MPU6050.Arduino als de controller en de sensor MPU6050 gebruiken om te bepalen van het evenwicht. Gewoon een eenvoudige seriële Bluetooth module toevoegen en een Bluetooth seriële Controller AP
SainSmart InstaBots rechtop Rover (Self Balancing Robot met Arduino)

SainSmart InstaBots rechtop Rover (Self Balancing Robot met Arduino)

Rechtop Rover is een zelfbalancerende robot die werd ontworpen door SainSmart. Ze maakten het echt eenvoudig. Zoals u zien kunt, zijn er slechts 8 draden op de robot en 8 draden op de controller. Dus laten we het weten hoe het werkt!ONDERDELEN IN HET
Self Balancing Robot met LCD

Self Balancing Robot met LCD

De gewijzigde versie van mijn mpu6050 balancing robot stabieler met LCD en voorbeeld van verbinding 2 i2c op dezelfde pincodeVideo 1Video 2Stap 1: Stap 1: ◾L298N dual motor stuurprogramma breakout board◾L298N dual motor stuurprogramma breakout board1
R/C Auto Balancing Robot

R/C Auto Balancing Robot

Hallo! Dit is Kaeru geen Ojisan.Veel robots van het evenwicht (zelfs met open-source code) vinden we in de website.Vervolgens heb ik geprobeerd om te vinden een balancing robot op basis van een werkelijke auto of een commercieel verkocht R/C auto zoa
Bouwen van een modulaire Robot Chassis met Actobotics

Bouwen van een modulaire Robot Chassis met Actobotics

Ik hield van mijn vroege kinderjaren robots. De eerste film robots ik herinner me ooit echt wens eerst, waar de drie bots "Stille Running", (nog steeds een van mijn favoriete films!) Die goofy beetje wandelen dozen bereikte een hoogtepunt van mi
B-robot EVO. De self balancing robot

B-robot EVO. De self balancing robot

Hoe werkt het?B-ROBOT is een op afstand bestuurbaar self balancing arduino robot gemaakt met 3D gedrukte delen. Met slechts twee wielen vermag B-ROBOT haar evenwicht hele tijd door met behulp van zijn interne sensoren en rijden de motoren. Kunt u uw
Borstelloze Gimbal Balancing Robot

Borstelloze Gimbal Balancing Robot

Het volgende project is een gevolg van het bekijken van de video Cubli en steeds geïnteresseerd zijn in de controle van unstable evenwicht met Borstelloze motoren. De eenvoudigere omgekeerde slinger probleem werd besloten om het project te voltooien
Het gebruik van een Android toestel en Lego NXT een tweewielige Self-Balancing Robot te bouwen

Het gebruik van een Android toestel en Lego NXT een tweewielige Self-Balancing Robot te bouwen

Vandaag zal ik u leren hoe maak je een Android aangedreven en gecontroleerde tweewielige zelfbalancerende robot met Lego NXT.Ten eerste, laten we eens kijken een test video voor de laatste robot.Hier is een andere tests op de helling:Om te bouwen van
Een eenvoudig en zeer gemakkelijk omgekeerde slinger Balancing Robot

Een eenvoudig en zeer gemakkelijk omgekeerde slinger Balancing Robot

Laten we een eenvoudig omgekeerde balancing robot, en werken het.U moet alleen een halve dag doen, hebt u een arduino en sommige materialen.[een video van een robot die u zou maken]Inleiding:Na een paar met arduino werken, heb ik gedacht van het make
Arduino Self Balancing Robot

Arduino Self Balancing Robot

In dit project die zal ik beschrijven de bouw van robots in evenwicht met Arduino.We staan uitgelegd in onze vorige versie van het android gecontroleerde project. In dit project gaan we tot onze controle. Laten we laten we krijgen op onze bouwproject
Chappie-zelftest-Balancing robot

Chappie-zelftest-Balancing robot

Na het krijgen van zo veel gefrustreerd over het afstemmen van de PID van de quadcopter, heb ik besloten om eerst meester van PID op sommige basisproject en dit project. Zelfbalancerende robot lijkt een inactief keuze. Aangezien er geen nieuwe en nog
Maak een Wi-Fi Controlled Robot met LinkIt ONE

Maak een Wi-Fi Controlled Robot met LinkIt ONE

Hier is een stap voor stap gids die u bouwen van de eerste robot en complexiteit, toevoegen helpen zal als u volgen. Naast het gebouw een fundamentele hindernis vermijden robot met een ultrasone sensor en Sparkfun motor stuurprogramma , zult u ook le
Bouw een Robot viervoeter Actobotics

Bouw een Robot viervoeter Actobotics

Hoe maak je een 4-legged wandelende robot met behulp van onderdelen van de Actobotics van ServoCity.com:Het werkpaard van deze robot, en wat maakt het relatief eenvoudig om te bouwen, zijn de servoblocks van Actobotics. Deze handige onderdelen kunnen
Hoe maak je kleine robots met nRover bestuur

Hoe maak je kleine robots met nRover bestuur

De nRover, is een kleine bord gemaakt om te bouwen van kleine robots zoals UGV (onbemande ground voertuigen), lijn volgeling of Domotica, het kan worden gecontroleerd door wifi, Bluetooth en radio-controle. Het belangrijkste doel is de ontwikkeling v