Enkla RC bil för nybörjare (Android kontroll över Bluetooth) (10 / 10 steg)

Steg 10: programvara

Programmet skrevs i Arduino IDE 1,01.

#include "EEPROM.h"

#define D1 2 / / rotationsriktning motor 1
#define M1 3 / / PWM vänster motor
#define D2 4 / / rotationsriktning motor 2
#define M2 5 / / PWM höger motor
#define HORN 13 / / ytterligare kanal 1
#define autoOFF 2500 / / millisekunder efter som stannar roboten när anslutningen

#define cmdL 'L' / / UART-kommando för vänster motor
#define cmdR 'R' / / UART-kommando för rätt motor
#define cmdH 'H' / / UART-kommando för ytterligare kanal (till exempel Horn)
#define cmdF 'F' / / UART-kommando för EEPROM drift
#define cmdr 'r' / / UART-kommando för EEPROM drift (Läs)
#define cmdw "w" / / UART-kommando för EEPROM drift (skriva)

char incomingByte; inkommande data

char L_Data [4]. matrisdata för vänster motor
byte L_index = 0; index för array L
char R_Data [4]. matrisdata för rätt motor
byte R_index = 0; index i matrisen R
char H_Data [1]. matrisdata för ytterligare kanal
byte H_index = 0; index i matrisen H
char F_Data [8]. matrisdata för EEPROM
byte F_index = 0; index i matrisen F
röding, kommando; kommandot

osignerade långa currentTime, lastTimeCommand, autoOFF;

void setup() {
Serial.BEGIN(9600); initiering av UART
pinMode (HORN, OUTPUT); Ytterligare en kanal
pinMode (D1, OUTPUT); utgång för motor rotation
pinMode (D2, OUTPUT); utgång för motor rotation
/ * EEPROM.write(0,255);
EEPROM.write(1,255);
EEPROM.write(2,255);
EEPROM.write(3,255); * /
timer_init(); initiering av programvara timer
}

void timer_init() {
uint8_t sw_autoOFF = EEPROM.read(0); Läs EEPROM "är aktiverad eller inte stoppa bilen när du förlorar anslutningen"
om (sw_autoOFF == '1') {/ / om aktiverad
char var_Data [3].
var_Data [0] = EEPROM.read(1);
var_Data [1] = EEPROM.read(2);
var_Data [2] = EEPROM.read(3);
autoOFF = atoi (var_Data) * 100; variabel autoOFF ms
}
annat if (sw_autoOFF == '0') {
autoOFF = 999999;
}
annat if(sw_autoOFF == 255) {
autoOFF = 2500; om EEPROM är tomt är dafault värdet 2,5 sek
}
currentTime = millis(); Läs tid som förflutit sedan programmet start
}

void loop() {
om (Serial.available() > 0) {/ / om UART upplysningar
incomingByte = Serial.read(); Raed byte
IF(incomingByte == cmdL) {/ / om mottagna data för vänster motor L
kommandot = cmdL; aktuella kommandot
MEMSET(L_Data,0,sizeof(L_Data)); Rensa array
L_index = 0; återställa vektorindex
}
annat if(incomingByte == cmdR) {/ / om mottagna data för vänster motor R
kommandot = cmdR;
MEMSET(R_Data,0,sizeof(R_Data));
R_index = 0;
}
annat if(incomingByte == cmdH) {/ / om mottagna data för ytterligare kanal
kommandot = cmdH;
MEMSET(H_Data,0,sizeof(H_Data));
H_index = 0;
}
annat if(incomingByte == cmdF) {/ / om mottagna data för EEPROM op
kommandot = cmdF;
MEMSET(F_Data,0,sizeof(F_Data));
F_index = 0;
}
annat if (incomingByte == '\r') kommando = "e"; slutet av raden
annat if (incomingByte == "\t") kommando = 't'; slutet av raden för EEPROM op

om (kommandot == cmdL & & incomingByte! = cmdL) {
L_Data [L_index] = incomingByte; lagra varje byte i matrisen
L_index ++; Increment vektorindex
}
annars om (kommandot == cmdR & & incomingByte! = cmdR) {
R_Data [R_index] = incomingByte;
R_index ++;
}
annars om (kommandot == cmdH & & incomingByte! = cmdH) {
H_Data [H_index] = incomingByte;
H_index ++;
}
annars om (kommandot == cmdF & & incomingByte! = cmdF) {
F_Data [F_index] = incomingByte;
F_index ++;
}
annars om (kommandot == "e") {/ / om vi tar linjeändpunkt
Control4WD(atoi(L_Data),atoi(R_Data),atoi(H_Data));
Delay(10);
}
annars om (kommandot == 't') {/ / om vi tar linjeändpunkt som EEPROM
Flash_Op(F_Data[0],F_Data[1],F_Data[2],F_Data[3],F_Data[4]);
}
lastTimeCommand = millis(); Läs tid som förflutit sedan programmet start
}
IF(Millis() > = (lastTimeCommand + autoOFF)) {/ / jämföra nuvarande timern med variabel lastTimeCommand + autoOFF
Control4WD(0,0,0); Stoppa bilen
}
}

void Control4WD (int mLeft, int mRight, uint8_t Horn) {

bool directionL, directionR; rotationsriktning motor L298N
byte valueL, värderingsman; PWM M1, M2 (0-255)

om (mLeft > 0) {
valueL = mLeft;
directionL = 0;
}
annars om (mLeft < 0) {
valueL = 255 - abs(mLeft);
directionL = 1;
}
annat {
directionL = 0;
valueL = 0;
}

om (mRight > 0) {
värderingsman = mRight;
directionR = 0;
}
annars om (mRight < 0) {
värderingsman = 255 - abs(mRight);
directionR = 1;
}
annat {
directionR = 0;
värderingsman = 0;
}

analogWrite (M1, valueL). ställa in hastigheten för vänster motor
analogWrite (M2, värderingsman); ställa in hastigheten för rätt motor
digitalWrite (D1, directionL); ställa in rotationsriktning vänster motor
digitalWrite (D2, directionR); Ange rätt motor rotationsriktning

digitalWrite (HORN, Horn); Ytterligare en kanal
}

void Flash_Op (char FCMD, uint8_t z1, uint8_t z2, uint8_t z3, uint8_t z4) {

IF(FCMD == CMdR) {/ / om EEPROM data läsa kommando
Serial.Print("FData:"); Skicka EEPROM data
Serial.write(EEPROM.Read(0)); läsa värdet från minnet med 0 adress och skriva den till UART
Serial.write(EEPROM.Read(1));
Serial.write(EEPROM.Read(2));
Serial.write(EEPROM.Read(3));
Serial.Print("\r\n"); Markera slutet på överföring av uppgifter EEPROM
}
annat if(FCMD == cmdw) {/ / om EEPROM data skriver kommandot
EEPROM.write(0,z1); Z1 posten till ett minne med 0 adress
EEPROM.write(1,z2);
EEPROM.write(2,z3);
EEPROM.write(3,z4);
timer_init(); initiera om timern
Serial.Print("FWOK\r\n"); Skicka ett meddelande som data framgångsrikt skrivs till EEPROM
}

Koden använder en för att arbeta med EEPROM AVR-minne. Arduino ombord av USART från Bluetooth-modulen mottar data redo för vänster och höger motor. Alla grundläggande beräkningar utförs i Android ansökan.

Projektstruktur i Eclipse du kan se på skärmdumpen ovan.

Du kan hämta källkoden för Arduino, och projektet för Eclipse
Hämta APK ansökan om Android-enhet

Den senaste programvaruversionen finns på denna sida
Video demonstration den virtuella ratt läget (1.2 version och ovan):

PS Ledsen för min dåliga engelska