Robotic kamera Dolly System (28 / 49 steg)

Steg 28: Programmera Arduinos

Ladda upp denna kod till Arduino kontroll touch sköld:

Kamera rigg Touch skärmen Controller

#include < Wire.h >

#include < Adafruit_GFX.h > / / Core grafik bibliotek
#include < Adafruit_TFTLCD.h > / / maskinvaruspecifika bibliotek
#include < TouchScreen.h >

#if defined(__SAM3X8E__)
#undef __FlashStringHelper::F(string_literal)
#define F(string_literal) string_literal
#endif

#ifndef USE_ADAFRUIT_SHIELD_PINOUT
#error "denna skiss är avsedd att användas med TFT LCD sköld. Se till att USE_ADAFRUIT_SHIELD_PINOUT är #defined i filen Adafruit_TFTLCD.h library."
#endif

Dessa är stiften för shield!
#define YP A1 / / måste vara en analog stift, Använd "En" notation!
#define XM A2 / / måste vara en analog stift, Använd "En" notation!
#define YM 7 / / kan vara en digital pin
#define XP 6 / / kan vara en digital pin

#ifdef __SAM3X8E__
#define TS_MINX 125
#define TS_MINY 170
#define TS_MAXX 880
#define TS_MAXY 940
#else
#define TS_MINX 150
#define TS_MINY 120
#define TS_MAXX 920
#define TS_MAXY 940
#endif

För bättre tryck precision behöver vi veta motståndet
mellan X + och X - använda någon multimeter att läsa den
För som använder vi, dess 300 ohm över X-plattan
TouchScreen ts = pekskärm (XP, YP, XM, YM, 300);

#define LCD_CS A3
#define LCD_CD A2
#define LCD_WR A1
#define LCD_RD A0

Tilldela vissa gemensamma värden som 16-bitars färg läsbara namn:
#define svart 0x0000
#define blå 0x001F
#define röd 0xF800
#define GREEN 0x07E0
#define CYAN 0x07FF
#define MAGENTA 0xF81F
#define gul 0xFFE0
#define vit 0xFFFF
#define LBLUE 0x65FF

Adafruit_TFTLCD tft;

int oldcolor, currentcolor;

bool pan = 1;
int panPosition1 = 20;
int panPosition2 = 20;

bool tilt = 0;
int tiltPosition1 = 20;
int tiltPosition2 = 20;

bool enhet = 0;
int drivePosition1 = 20;
int drivePosition2 = 20;

bool tid = 0;
int timePosition1 = 20;
int timePosition2 = 20;

int startSend = 0;

int x;

void setup(void) {
Wire.BEGIN(); gå med i2c bussen (adress valfritt för master)

Serial.BEGIN(9600);

TFT.Reset();

uint16_t ID = tft.readID();

IF(Identifier == 0x9325) {
Serial.println F ("hittade ILI9325 LCD förare").
} annat if(identifier == 0x9328) {
Serial.println F ("hittade ILI9328 LCD förare").
} annat if(identifier == 0x7575) {
Serial.println F ("hittade HX8347G LCD förare").
} annat {
Serial.Print (F ("okänd LCD förare chip:"));
Serial.println (ID, HEX);
hemkomst.
}

TFT.BEGIN(Identifier);
tft.setRotation(1);
tft.fillScreen(BLACK);

drawMenu();

tft.drawRect (0, 0, 58, 40, vit);

Ange inledande reglaget stater
tft.drawRect (19, 89, 272, 6, vit);
tft.fillRect (20, 90, 270, 4, gul);

tft.drawRect (panPosition1, 71, 17, 42, vit);
tft.fillRect ((panPosition1 + 1), 72, 15, 40, MAGENTA);

tft.drawRect (19, 169, 272, 6, vit);
tft.fillRect (20, 170, 270, 4, gul);

tft.drawRect (panPosition2, 151, 17, 42, vit);
tft.fillRect ((panPosition2 + 1), 152, 15, 40, MAGENTA);

currentcolor = röd;

pinMode (13, OUTPUT);
}

#define MINPRESSURE 10
#define MAXPRESSURE 1000

void loop() {

digitalWrite 13, hög.
Peka p = ts.getPoint();
digitalWrite 13, låg.

om dela stift, måste fixa riktningarna av touchscreen stiften
pinMode (XM, OUTPUT);
pinMode (YP, OUTPUT);

Vi har vissa minsta tryck som vi anser vara "giltigt"
Tryck på 0: ingen pressning!
om (p.z > MINPRESSURE & & p.z < MAXPRESSURE) {

skala från 0 -> 1023 till tft.width
p.x = karta (p.x, TS_MINX, TS_MAXX, tft.width(), 0);
p.y = karta (p.y, TS_MINY, TS_MAXY, tft.height(), 0);

//****************************
KOD FÖR ÖVRE MENYN VAL!
//****************************

om (p.x > 300) {
oldcolor = currentcolor;

om (p.y < 58) {
currentcolor = röd;
tft.drawRect (0, 0, 58, 40, vit);
panorera = 1;
lutning = 0;
enhet = 0;
tid = 0;
drawSliders();
} else om (p.y < 140) {
currentcolor = LBLUE;

tft.drawRect (58, 0, 82, 40, vit);
panorera = 0;
lutning = 1;
enhet = 0;
tid = 0;
drawSliders();
} else om (p.y < 180) {
currentcolor = blå;

tft.drawRect (140, 0, 96, 40, vit);
panorera = 0;
lutning = 0;
enhet = 1;
tid = 0;
drawSliders();
} else om (p.y < 240) {
currentcolor = grön,
tft.drawRect (236, 0, 82, 40, vit);
panorera = 0;
lutning = 0;
enhet = 0;
tid = 1;
drawSliders();
}
}

//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
BEHÖVER JAG DETTA ALLS???
KAN DET BARA LÄSA RITA-MENYN???

om (oldcolor! = currentcolor) {
om (oldcolor == RED) drawMenu();
om (oldcolor == LBLUE) drawMenu();
om (oldcolor == grönt) drawMenu();
om (oldcolor == blå) drawMenu();
}

//****************************
START KOD FÖR VAL!
//****************************

om (p.x < 40) {
om (p.y > 180) {
tft.drawRect (200-220, 96, 40, vit);
startSend = 1;
}
}

//****************
REGLAGET KODEN!!!
//****************

ÖVRE SKJUTREGLAGET
om (p.x > 180 & & p.x < 260) {
om (p.y < 350) {
om (p.y > = 20) {/ / eller så... för första svart ruta...

behöver mappa botten och topp mappa!!!
p.y = karta (p.y, 0, 0, 240, 300);

tft.fillRect (10, 71, (p.y - 10), 50, svart);
}

tft.drawRect ((p.y-1), 71, 17, 42, vit);
tft.fillRect (p.y, 72, 15, 40, MAGENTA);
tft.fillRect ((p.y + 16), 71, (282 - p.y), 50, svart);

tft.drawRect ((p.y + 15), 89, (272 - p.y), 6, vit);
tft.fillRect ((p.y + 16), 90, (270 - p.y), 4, gul);

tft.drawRect (19, 89, (p.y - 19), 6, vit);
tft.fillRect (20, 90, (p.y - 20), 4, gul);

om (panorera == 1) {
panPosition1 = p.y;
Serial.println(panPosition1);
} annat if(tilt == 1) {
tiltPosition1 = p.y;
} annat if(drive == 1) {
drivePosition1 = p.y;
} annat if(time == 1) {
timePosition1 = p.y;
}
}
}

NEDRE REGLAGET
om (p.x > 80 & & p.x < 160) {
om (p.y < 350) {
om (p.y > = 20) {/ / eller så... för första svart ruta...

behöver mappa botten och topp mappa!!!
p.y = karta (p.y, 0, 0, 240, 300);

tft.fillRect (10, 151, (p.y - 10), 50, svart);
}

tft.drawRect ((p.y-1), 151, 17, 42, vit);
tft.fillRect (p.y, 152, 15, 40, MAGENTA);
tft.fillRect ((p.y + 16), 151, (282 - p.y), 50, svart);

tft.drawRect ((p.y + 15), 169, (272 - p.y), 6, vit);
tft.fillRect ((p.y + 16), 170, (270 - p.y), 4, gul);

tft.drawRect (19, 169, (p.y - 19), 6, vit);
tft.fillRect (20, 170, (p.y - 20), 4, gul);

om (panorera == 1) {
panPosition2 = p.y;
Serial.println(panPosition2);
} annat if(tilt == 1) {
tiltPosition2 = p.y;
} annat if(drive == 1) {
drivePosition2 = p.y;
} annat if(time == 1) {
timePosition2 = p.y;
}
}
}

//**************************
SÄNDER TILL ANDRA ARDUINO
//**************************

IF(startSend == 1) {
transmitValues();
startSend = 0;
Delay(2000);
drawMenu();
om (panorera == 1) tft.drawRect (0, 0, 58, 40, vit);
om (luta == 1) tft.drawRect (58, 0, 82, 40, vit);
om (enhet == 1) tft.drawRect (140, 0, 96, 40, vit);
om (tid == 1) tft.drawRect (236, 0, 82, 40, vit);
}

}
}

void transmitValues() {
Wire.beginTransmission(2); överföra till enhet #2
x = panPosition1;
Wire.write("a"); skickar fem byte
Wire.write(x);
Wire.endTransmission(); stoppa överföring

Delay(100);

Wire.beginTransmission(2); överföra till enhet #2
x = panPosition2;
Wire.write("b"); skickar fem byte
Wire.write(x);
Wire.endTransmission(); stoppa överföring

Delay(100);

Wire.beginTransmission(2); överföra till enhet #2
x = tiltPosition1;
Wire.write("c");
Wire.write(x);
Wire.endTransmission(); stoppa överföring

Delay(100);

Wire.beginTransmission(2); överföra till enhet #2
x = tiltPosition2;
Wire.write("d");
Wire.write(x);
Wire.endTransmission(); stoppa överföring

Delay(100);

Wire.beginTransmission(2); överföra till enhet #2
x = drivePosition1;
Wire.write("e"); skickar fem byte
Wire.write(x);
Wire.endTransmission(); stoppa överföring

Delay(100);

Wire.beginTransmission(2); överföra till enhet #2
x = drivePosition2;
Wire.write("f"); skickar fem byte
Wire.write(x);
Wire.endTransmission(); stoppa överföring

Delay(100);

Wire.beginTransmission(2); överföra till enhet #2
x = timePosition1;
Wire.write("g");
Wire.write(x);
Wire.endTransmission(); stoppa överföring

Delay(100);

Wire.beginTransmission(2); överföra till enhet #2
x = timePosition2;
Wire.write("h");
Wire.write(x);
Wire.endTransmission(); stoppa överföring

Delay(100);

Wire.beginTransmission(2); överföra till enhet #2
x = startSend;
Wire.write("i");
Wire.write(x);
Wire.endTransmission(); stoppa överföring
}

void drawSliders() {

om (oldcolor! = currentcolor) {
tft.fillRect (10, 60, 300, 200, svart);
}

IF(Pan == 1) {
tft.drawRect (19, 89, 272, 6, vit);
tft.fillRect (20, 90, 270, 4, gul);

tft.drawRect (panPosition1, 71, 17, 42, vit);
tft.fillRect ((panPosition1 + 1), 72, 15, 40, MAGENTA);

tft.drawRect (19, 169, 272, 6, vit);
tft.fillRect (20, 170, 270, 4, gul);

tft.drawRect (panPosition2, 151, 17, 42, vit);
tft.fillRect ((panPosition2 + 1), 152, 15, 40, MAGENTA);
} annat if(tilt == 1) {
tft.drawRect (19, 89, 272, 6, vit);
tft.fillRect (20, 90, 270, 4, gul);

tft.drawRect (tiltPosition1, 71, 17, 42, vit);
tft.fillRect ((tiltPosition1 + 1), 72, 15, 40, MAGENTA);

tft.drawRect (19, 169, 272, 6, vit);
tft.fillRect (20, 170, 270, 4, gul);

tft.drawRect (tiltPosition2, 151, 17, 42, vit);
tft.fillRect ((tiltPosition2 + 1), 152, 15, 40, MAGENTA);
} annat if(drive == 1) {
tft.drawRect (19, 89, 272, 6, vit);
tft.fillRect (20, 90, 270, 4, gul);

tft.drawRect (drivePosition1, 71, 17, 42, vit);
tft.fillRect ((drivePosition1 + 1), 72, 15, 40, MAGENTA);

tft.drawRect (19, 169, 272, 6, vit);
tft.fillRect (20, 170, 270, 4, gul);

tft.drawRect (drivePosition2, 151, 17, 42, vit);
tft.fillRect ((drivePosition2 + 1), 152, 15, 40, MAGENTA);
} annat if(time == 1) {
tft.drawRect (19, 89, 272, 6, vit);
tft.fillRect (20, 90, 270, 4, gul);

tft.drawRect (timePosition1, 71, 17, 42, vit);
tft.fillRect ((timePosition1 + 1), 72, 15, 40, MAGENTA);

tft.drawRect (19, 169, 272, 6, vit);
tft.fillRect (20, 170, 270, 4, gul);

tft.drawRect (timePosition2, 151, 17, 42, vit);
tft.fillRect ((timePosition2 + 1), 152, 15, 40, MAGENTA);
}

}

void drawMenu() {

tft.fillRect (236, 0, 82, 40, grön);
tft.fillRect (140, 0, 96, 40, blå);
tft.fillRect (58, 0, 82, 40, LBLUE);
tft.fillRect (0, 0, 58, 40, röd);

tft.drawChar (2, 10, "P", vit, röd, 3);
tft.drawChar (20, 10, "A", vit, röd, 3);
tft.drawChar (38, 10, 'N', vit, röd, 3);

tft.drawChar (64, 10, 'T', vit, LBLUE, 3);
tft.drawChar (82, 10, "I", vit, LBLUE, 3);
tft.drawChar (100, 10, 'L', vit, LBLUE, 3);
tft.drawChar (118, 10, 'T', vit, LBLUE, 3);

tft.drawChar (144, 10, skulle ', vit, blå, 3);
tft.drawChar (162, 10, 'R', vit, blå, 3);
tft.drawChar (180, 10, "I", vit, blå, 3);
tft.drawChar (198, 10, "V", vit, blå, 3);
tft.drawChar (216, 10, "E", vit, blå, 3);

tft.drawChar (242, 10, 'T', vit, grön, 3);
tft.drawChar (260, 10, "I", vit, grön, 3);
tft.drawChar (278, 10, är ', vit, grön, 3);
tft.drawChar (296, 10, "E", vit, grön, 3);

tft.fillRect (200-220, 96, 40, blå);
tft.drawChar (224, 210, 'S', vit, blå, 3);
tft.drawChar (242, 210, 'T', vit, blå, 3);
tft.drawChar (260, 210, 'A', vit, blå, 3);
tft.drawChar (278, 210, 'R', vit, blå, 3);
tft.drawChar (296, 210, 'T', vit, blå, 3);

}
< br >

Ladda upp denna kod till Arduino som kommer att kontrollera motorn:

Kamera rigg Motor Controller

#include < Servo.h >

#define ENC_A 14
#define ENC_B 15
#define ENC_PORT PINC

Servo panServo;
Servo tiltServo;

int avstånd = 0;

bool TillståndÄndra = 0;

int motorPin = 3; LED är ansluten till digital pin 9

flyta driveX = 0;
flyta tiltX = 0;
flyta panX = 0;
flyta timeX = 0;

flyta driveZ = 0;
flyta tiltZ = 0;
flyta panZ = 0;
flyta Picza = 0;

int distanceToGo = 0;

för program
int progStart = 0;

för att testa
int progStart = 1;

int motorSpeed;

float totalTilt;
float totalPan;
float totalDrive;

float panIncrement;
float tiltIncrement;
float driveIncrement;

flyta picsPerPanIncrement = 1;
flyta picsPerTiltIncrement = 1;
flyta picsPerDriveIncrement = 1;

int panSteps = 0;
int tiltSteps = 0;
int driveSteps = 0;

char dataRx [20].

#include < Wire.h >

void setup()
{
Wire.BEGIN(2); gå med i2c bussen med adress #2
Wire.onReceive(receiveEvent); Anmäl dig
Serial.BEGIN(9600); Starta följetong för utdata

panServo.attach(4);
tiltServo.attach(5);
tiltServo.writeMicroseconds(1100);
panServo.writeMicroseconds(1500);
Delay(10000);

pinMode (8, OUTPUT);

pinMode (ENC_A, indata);
digitalWrite (ENC_A, hög);
pinMode (ENC_B, indata);
digitalWrite (ENC_B, hög);

}

void loop() {

IF(progStart == 1) {

tiltX = karta (tiltX, 0, 255, 750, 1450);
tiltZ = karta (tiltZ, 0, 255, 750, 1450);

panX = karta (panX, 0, 255, 600, 2200);
panZ = karta (panZ, 0, 255, 600, 2200);

Serial.println(panX);
Serial.println(panZ);

om (timeX < 5) {
motorSpeed = 150;
driveX = (driveX, 0, 255, 0, 180);
timeX = 0;
} annat {
motorSpeed = 75.
driveX = (driveX, 0, 255, 0, 360);
}

totalPan = (panX - panZ);
totalPan = abs(totalPan);
totalTilt = tiltX - tiltZ;
totalTilt = abs(totalTilt);
totalDrive = driveX;

Serial.println(totalPan);

//***************************************************
räkna ut hur långt för att avancera innan du tar bilder
Alternativt hur många bilder att ta innan framåt
//***************************************************

//! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !
DESSA MÅSTE VARA JÄVLA FLÖTEN OCH SKIT!
//! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !

panIncrement = totalPan / Picza;
IF(totalPan < picZ) {
picsPerPanIncrement = 1 / panIncrement;
panIncrement = 1;
}

tiltIncrement = totalTilt / Picza;
IF(totalTilt < picZ) {
picsPerTiltIncrement = 1 / tiltIncrement;
tiltIncrement = 1;
}

driveIncrement = totalDrive / Picza;
IF(totalDrive < picZ) {
picsPerDriveIncrement = 1 / driveIncrement;
driveIncrement = 1;
}

//**************************************
flytta servon till inledande ståndpunkter
//**************************************

tiltServo.writeMicroseconds(tiltX);
panServo.writeMicroseconds(panX);
Delay(10000);

//**************************************
ta några bilder och flytta lite grejer
//**************************************

för (int takingPictures = 0; takingPictures < Picza; takingPictures ++) {

om (panSteps > = picsPerPanIncrement) {
IF(panX > panZ) {
panServo.writeMicroseconds (panX - panIncrement);
panX = panX - panIncrement;
} annat if(panX < panZ) {
panServo.writeMicroseconds (panX + panIncrement);
panX = panX + panIncrement;
} annat {
panServo.writeMicroseconds(panX);
}
panSteps = 0;
}

om (tiltSteps > = picsPerTiltIncrement) {
IF(tiltX > tiltZ) {
tiltServo.writeMicroseconds (tiltX - tiltIncrement);
tiltX = tiltX - tiltIncrement;
} annat if(tiltX < tiltZ) {
tiltServo.writeMicroseconds (tiltX + tiltIncrement);
tiltX = tiltX + tiltIncrement;
} annat {
tiltServo.writeMicroseconds(tiltX);
}
tiltSteps = 0;
}

om (driveSteps > = picsPerDriveIncrement) {
analogWrite (motorPin, motorSpeed);
While(Distance < distanceToGo) {
callEncoder();
}
analogWrite (motorPin, 0);
driveSteps = 0;
}

distanceToGo = distanceToGo + driveIncrement;

Delay(timeX * 500);
Serial.println("shoot!!!");

Ta bild
digitalWrite 8, hög. ansluta kameran avtryckaren
Delay(500); vänta en sekund
digitalWrite 8, låg. Koppla från kamera avtryckare
Delay(500);

panSteps = panSteps + 1.
tiltSteps = tiltSteps + 1.
driveSteps = driveSteps + 1.

progStart = 0;
}
}
}

funktion som körs när data begärs av master
denna funktion är registrerad som en händelse, se setup()
void receiveEvent(int holder)
{

heltal index = 0;
medan (1 < Wire.available()) / / loopa igenom alla utom sist
{
char c = Wire.read(); ta emot byte som ett tecken
Serial.Print(c); skriva ut den

dataRx [index ++] = c;
dataRx [index] = '\0';

}
int x = Wire.read(); ta emot byte som ett heltal
Serial.println(x); skriva ut heltalet

om (* dataRx == "a") {
panX = x;

Serial.Print ("OMG PARSNING PANX:");
Serial.println(panX);
} else om (* dataRx == "b") {
panZ = x;

Serial.Print ("OMG PARSNING PANZ:");
Serial.println(panZ);
} else om (* dataRx == "c") {
tiltX = x;

Serial.Print ("OMG PARSNING TILTX:");
Serial.println(tiltX);
} else om (* dataRx == hade ") {
tiltZ = x;

Serial.Print ("OMG PARSNING TILTZ:");
Serial.println(tiltZ);
} else om (* dataRx == "e") {
driveX = x;

Serial.Print ("OMG PARSNING DRIVEX:");
Serial.println(driveX);
} else om (* dataRx == "f") {
driveZ = x;

Serial.Print ("OMG PARSNING DRIVEZ:");
Serial.println(driveZ);
} else om (* dataRx == "g") {
timeX = x;

Serial.Print ("OMG PARSNING TIMEX:");
Serial.println(timeX);
} else om (* dataRx == "h") {
Picza = x;

Serial.Print ("OMG PARSNING PICZA:");
Serial.println(picZ);
} else om (* dataRx == "i") {
progStart = x;

Serial.Print ("OMG PARSNING START:");
Serial.println(progStart);
}

}

/ * Returnerar ändring encoder tillstånd (-1,0,1) * /
int8_t read_encoder()
{
statisk int8_t enc_states [] = {0, - 1,1,0,1,0,0, -1, - 1,0,0,1,0,1,-1,0};
statisk uint8_t old_AB = 0;
/**/
old_AB << = 2; kom ihåg tidigare tillstånd
old_AB | = (ENC_PORT & 0x03); Lägg till nuvarande tillstånd
Return (enc_states [(old_AB & 0x0f)]);
}

void callEncoder() {
analogWrite (motorPin, 0);
Delay(1000);
//
//30Dst @ 150Sp
//60Dst @ 75Sp
//60Dst @ 50Sp
//
medan (avstånd < 240) {
analogWrite (motorPin, 75);
//}

statisk uint8_t counter = 0; Denna variabel ska ändras med encoder input
int8_t tmpdata;
/**/
tmpdata = read_encoder();
om (tmpdata) {
Serial.Print ("Counter värde:");
Serial.println (counter, DEC);
räknaren += tmpdata;

IF(Counter == 255) {
TillståndÄndra = 1;
}

IF(Counter == 0) {
IF(stateChange == 1) {
TillståndÄndra = 0;
distans + = 1;

Serial.Print ("steg:");
Serial.println (avstånd, DEC);
}
}
}
}
< br >