Telefon kontrollerade stämningsbelysning (10 / 12 steg)

Steg 10: Införliva LED Strips

Kör följande skiss på Arduino:

/*
Telefon kontrollerade stämningsbelysning - Arduino kod
av Nicole Grimwood

Baserat på:
Seeed Wiki Bluetooth slav kod
http://www.seeedstudio.com/wiki/index.php?title=Bluetooth_Shield

Pololu LED Strip exempelkod
https://github.com/Pololu/Pololu-LED-Strip-Arduino

Denna kod är i public domain.
*/

#include < avr/pgmspace.h >
#include < SoftwareSerial.h > / / programvara Serial Port
#include < PololuLedStrip.h >

#define RxD 6 / / Detta är PIN-koden som Bluetooth (BT_TX) kommer att överföra till Arduino (RxD)
#define TxD 7 / / detta är PIN-koden som Bluetooth (BT_RX) tar emot från Arduino (TxD)

#define DEBUG_ENABLED 1

Skapa en ledStrip objekt på stift 12.
PololuLedStrip < 12 > ledStrip;

Skapa en buffert för att hålla 3 färger. Tar 180 byte.
#define LED_COUNT 3
rgb_color färger [LED_COUNT];

SoftwareSerial blueToothSerial(RxD,TxD);

#define DATA_1 (PORTC | = 0X01) / / DATA 1
#define DATA_0 (PORTC & = 0XFE) / / DATA 0
#define STRIP_PINOUT (DDRC = 0xFF)

void setup() {
Set avbrott vänliga True så att lampan
remsorna arbete med bluetooth sköld
PololuLedStripBase::interruptFriendly = sant;

pinMode (RxD, indata); Setup Arduinoen för att få INPUT från bluetooth sköld på Digital Pin 6
pinMode (TxD, OUTPUT); Setup Arduinoen för att skicka data (OUTPUT) till bluetooth sköld på Digital Pin 7

setupBlueToothConnection(); Används för att initiera Bluetooth sköld

}

void loop() {
char recvChar;
While(1) {
IF(blueToothSerial.available()) {/ / kolla om det finns någon data som skickas från den fjärranslutna bluetooth skölden
recvChar = blueToothSerial.read();
Serial.Print(recvChar); Skriva ut den fick till seriell Monitor (vid behov)
om karaktären fick är en, använda det vita mönstret
IF(recvChar=='a') {
Delay(500); nödvändiga för LED strips för att arbeta med bluetooth sköld
används för att tilldela färger till 3 avsnitt av LED strips
Colors[0]=(rgb_color) {250,250,250}.
Colors[1]=(rgb_color) {250,250,250}.
Colors[2]=(rgb_color) {250,250,250}.
ledStrip.write (färger, LED_COUNT);
}
om karaktär fick är b, använda rosa mönstret
IF(recvChar=='b') {
Delay(500);
Colors[0]=(rgb_color) {250,220,0}.
Colors[1]=(rgb_color) {250,220,0}.
Colors[2]=(rgb_color) {250,220,0}.
ledStrip.write (färger, LED_COUNT);
}
om tecken fick c, Använd det röda och orange mönstret
IF(recvChar=='c') {
Delay(500);
Colors[0]=(rgb_color) {250,0,0}.
Colors[1]=(rgb_color) {250,0,230}.
Colors[2]=(rgb_color) {250,0,0}.
ledStrip.write (färger, LED_COUNT);
}
om karaktär fick är d, använda det blå och lila mönstret
IF(recvChar=='d') {
Delay(500);
Colors[0]=(rgb_color) {0,220,0}.
Colors[1]=(rgb_color) {50,220,0}.
Colors[2]=(rgb_color) {0,220,0}.
ledStrip.write (färger, LED_COUNT);
}
}
}
}

Följande kod är nödvändigt att installera bluetooth sköld
void setupBlueToothConnection() {
blueToothSerial.begin(38400); Ange BluetoothBee BaudRate till standard överföringshastigheten 38400
blueToothSerial.print("\r\n+STWMOD=0\r\n"); ställa in bluetooth arbetet i slav-läge
blueToothSerial.print("\r\n+STNA=SeeedBTSlave\r\n"); ställa in bluetooth-namn som "SeeedBTSlave"
blueToothSerial.print("\r\n+STOAUT=1\r\n"); Tillåta ihopkopplade enheten ansluta mig
blueToothSerial.print("\r\n+STAUTO=0\r\n"); Automatisk anslutning bör vara förbjudet här
Delay(2000); Denna försening krävs.
blueToothSerial.print("\r\n+INQ=1\r\n"); göra slav bluetooth inquirable
Serial.println ("slav bluetooth är inquirable!");
Delay(2000); Denna försening krävs.
blueToothSerial.flush();
}

Kör följande skiss på Android-enhet:

/*
Telefon kontrollerade stämningsbelysning - Android skiss
av Nicole Grimwood

Baserat på: BluetoothApp1
skapad den 25 mars, 2013
av ScottC
*/

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.widget.Toast;
import android.view.Gravity;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;

import java.util.UUID;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import android.os.Handler;
import android.os.Message;
import android.util.Log;

import android.bluetooth.BluetoothServerSocket;
import android.bluetooth.BluetoothSocket;
import apwidgets.*;
offentliga BluetoothSocket scSocket;

Används för GUI ***
APWidgetContainer widgetContainer;
APButton whiteButton, pinkButton, redOrangeButton, blueButton;
String buttonText = "";
int buttonWidth = 0;
int buttonHeight = 0;
int n = 5; antal knappar
int gap = 10; klyftan mellan knappar

booleska foundDevice = false; Sant, blir skärmen grön.
booleska BTisConnected = false; Sant, blir skärmen lila.

Meddelandetyper används av Handler
offentliga statisk sista int MESSAGE_WRITE = 1;
offentliga statisk sista int MESSAGE_READ = 2;
String readMessage = "";

Används för att skicka byte till Arduino
SendReceiveBytes sendReceiveBT = null;

Få standard Bluetooth adapter
BluetoothAdapter bluetooth = BluetoothAdapter.getDefaultAdapter();

/ * StartActivityForResult() inom setup() lanserar en
Aktivitet som används för att be användaren att aktivera Bluetooth.
Följande onActivityResult() metod kallas när detta
Aktivitet avslutas. */

skyddade void onActivityResult (int requestCode, int resultCode, uppsåt data) {
om (requestCode == 0) {
om (resultCode == RESULT_OK) {
ToastMaster ("Bluetooth har slagits på");
}
annat {
ToastMaster ("du måste slå Bluetooth!");
}
}
}

/ * Skapa en BroadcastReceiver som senare kommer att användas för att
får namn på Bluetooth-enheter inom räckhåll. */
BroadcastReceiver myDiscoverer = ny myOwnBroadcastReceiver();

/ * Skapa en BroadcastReceiver som senare kommer att användas för att
identifiera om Bluetooth-enheten är ansluten * /
BroadcastReceiver checkIsConnected = ny myOwnBroadcastReceiver();

Hundföraren som får information tillbaka från uttaget
privat slutliga Handler mHandler = ny Handler() {

public void handleMessage (meddelande msg) {
växel (msg.what) {
fall MESSAGE_WRITE:
Göra något när du skriver
bryta;
fall MESSAGE_READ:
Få byte från msg.obj
byte [] readBuf = (byte[]) msg.obj;
konstruera en sträng från de giltig byte i bufferten
readMessage = ny sträng (readBuf, 0, msg.arg1);
bryta;
}
}
};

void setup() {
Orientation(LANDSCAPE);

//Setup GUI********************************
buttonWidth=((width/n)-(n*gap));
buttonHeight=(height/2);
widgetContainer = ny APWidgetContainer(this); skapa nya behållare för widgets
whiteButton = ny APButton((buttonWidth*(n-5)+(gap*1)), gap, buttonWidth, buttonHeight, "Vit"); Skapa en färg tona knapp
pinkButton = ny APButton((buttonWidth*(n-4)+(gap*2)), gap, buttonWidth, buttonHeight, "Rosa"); Skapa en mönster-knapp
redOrangeButton = ny APButton((buttonWidth*(n-3)+(gap*3)), gap, buttonWidth, buttonHeight, "Röd Orange"); Skapa en röd orange knapp
blueButton = ny APButton((buttonWidth*(n-2)+(gap*4)), gap, buttonWidth, buttonHeight, "Blå"); Skapa en blå knapp
widgetContainer.addWidget(whiteButton); Placera färg tona knapp i behållare
widgetContainer.addWidget(pinkButton); Placera mönstret fade knapp i behållare
widgetContainer.addWidget (redOrangeButton), //place röd orange knappen i behållare
widgetContainer.addWidget (blueButton), //place blå knapp i behållare
Background(0); Börja med en svart bakgrund

/ * OM Bluetooth inte är aktiverat, då frågar användaren tillåtelse att aktivera den * /
om (! bluetooth.isEnabled()) {
Uppsåt requestBluetooth = ny Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
startActivityForResult (requestBluetooth, 0);
}

/ * Om Bluetooth är nu aktiverat, sedan registrera en broadcastReceiver för att rapportera någon
upptäckt Bluetooth-enheter och startar att upptäcka * /
om (bluetooth.isEnabled()) {
registerReceiver (myDiscoverer, nya IntentFilter(BluetoothDevice.ACTION_FOUND));
registerReceiver (checkIsConnected, nya IntentFilter(BluetoothDevice.ACTION_ACL_CONNECTED));

Starta bluetooth upptäckt om det inte gör det redan
om (! bluetooth.isDiscovering()) {
bluetooth.startDiscovery();
}
}
}

void draw() {
Visas en grön skärm om en enhet har hittats,
Visa en lila skärmen när en anslutning görs till enheten
om (foundDevice) {
om (BTisConnected) {
bakgrund (200, 70, 255); lila skärmen
}
annat {
bakgrund (0, 200, 50); grön skärm
}
}

Ändra texten baserat på knappen trycks.
text (buttonText, 20, buttonHeight+(buttonHeight/2));

}

/ * Denna BroadcastReceiver visas upptäckta Bluetooth-enheter * /
allmän klass myOwnBroadcastReceiver sträcker sig BroadcastReceiver {
ConnectToBluetooth connectBT;

public void onReceive (kontext sammanhang, avsikt intent) {
Sträng action=intent.getAction();
ToastMaster ("ACTION:" + åtgärder);

Anmälan som BluetoothDevice finns
om (BluetoothDevice.ACTION_FOUND.equals(action)) {
Visa namnet på upptäckta enheten
String discoveredDeviceName = intent.getStringExtra(BluetoothDevice.EXTRA_NAME);
ToastMaster ("upptäckt:" + discoveredDeviceName);

Visa mer information om upptäckta enheten
BluetoothDevice discoveredDevice = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);

Ändra foundDevice till true som gör skärmen bli grön
foundDevice = sant;

Ansluta till upptäckta bluetooth-enheten (SeeedBTSlave)
om (discoveredDeviceName.equals("SeeedBTSlave")) {
ToastMaster ("ansluter du nu!");
unregisterReceiver(myDiscoverer);
connectBT = ny ConnectToBluetooth(discoveredDevice);
Ansluta till den enheten i en ny tråd
nya Thread(connectBT).start();
}
}

Anmälan om bluetooth-enhet är ansluten
om (BluetoothDevice.ACTION_ACL_CONNECTED.equals(action)) {
ToastMaster (anslutna _ YAY");
int counter = 0;
medan (scSocket == null) {
gör ingenting
}
ToastMaster ("scSocket" + scSocket);
BTisConnected = sant; Vrid skärmen lila
om (scSocket! = null) {
sendReceiveBT = ny SendReceiveBytes(scSocket);
nya Thread(sendReceiveBT).start();
Sträng börjar = "a";
byte [] myByte = stringToBytesUTFCustom(begin);
sendReceiveBT.write(myByte);
}
}
}
}

offentliga statisk byte [] stringToBytesUTFCustom (String str) {
char [] buffert = str.toCharArray();
byte [] b = nya byte[buffer.length << 1];
för (int jag = 0; jag < buffer.length; i ++) {
int bpos = jag << 1.
b [bpos] = (byte) ((buffert [i] & 0xFF00) >> 8);
b [bpos + 1] = (byte) (buffert [i] & 0x00FF);
}
returnera b;
}

allmän klass ConnectToBluetooth implementerar Runnable {
privat BluetoothDevice btShield;
privat BluetoothSocket mySocket = null;
privat UUID uuid = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");

offentliga ConnectToBluetooth (BluetoothDevice bluetoothShield) {
btShield = bluetoothShield;
försök {
mySocket = btShield.createRfcommSocketToServiceRecord(uuid);
}
fånga (IOException createSocketException) {
Problem med att skapa en socket
Log.e ("ConnectToBluetooth", "Fel med Socket");
}
}

public void run() {
/ * Avbryta upptäckten på Bluetooth-kortet att förhindra långsam anslutning * /
bluetooth.cancelDiscovery();

försök {
/ * Ansluta till bluetoothShield genom uttaget. Detta kommer att blockera
tills det lyckas eller kastar en IOException * /
mySocket.connect();
scSocket = mySocket;
}
fånga (IOException connectException) {
Log.e ("ConnectToBluetooth", "Fel med socketanslutning");
försök {
mySocket.close(); Försök stänga uttaget
}
fånga (IOException closeException) {
}
hemkomst.
}
}

Gör att du kan få uttaget från denna klass
offentliga BluetoothSocket getSocket() {
återvända mySocket;
}

/ * Kommer att avbryta en pågående anslutning och stänga uttaget * /
public void cancel() {
försök {
mySocket.close();
}
fånga (IOException e) {
}
}
}

privat klass SendReceiveBytes implementerar Runnable {
privat BluetoothSocket btSocket;
privat InputStream btInputStream = null;
;
privat OutputStream btOutputStream = null;
Sträng TAG = "SendReceiveBytes";

offentliga SendReceiveBytes (BluetoothSocket socket) {
btSocket = socket;
försök {
btInputStream = btSocket.getInputStream();
btOutputStream = btSocket.getOutputStream();
}
fånga (IOException streamError) {
Log.e (TAG, "fel vid att få input eller output Stream");
}
}

public void run() {
byte [] buffert = nya byte [1024]; buffert butik för ström
int byte. -byte returnerade från read()

Hålla lyssna på InputStream tills ett undantag inträffar
medan (sant) {
försök {
Läsa från InputStream
byte = btInputStream.read(buffer);
Skicka de erhållna byte till UI aktiviteten
mHandler.obtainMessage (MESSAGE_READ, byte, -1, buffert)
.sendToTarget();
}
fånga (IOException e) {
Log.e (TAG, "Fel vid läsning från btInputStream");
bryta;
}
}
}

/ * Kalla detta från den huvudsakliga verksamheten att skicka data till den fjärranslutna enheten * /
public void write (byte [] byte) {
försök {
btOutputStream.write(bytes);
}
fånga (IOException e) {
Log.e (TAG, "Fel vid skrivning till btOutputStream");
}
}

/ * Kalla detta från den huvudsakliga verksamheten till stängningen anslutningen * /
public void cancel() {
försök {
btSocket.close();
}
fånga (IOException e) {
Log.e (TAG, "Fel vid stängning av btSocket");
}
}
}

/ * Min ToastMaster-funktion för att visa en meddelanderuta på skärmen * /
Annullera ToastMaster (sträng textToDisplay) {
Rosta myMessage = Toast.makeText(getApplicationContext(),
textToDisplay,
Toast.LENGTH_SHORT);
myMessage.setGravity (Gravity.CENTER, 0, 0);
myMessage.show();
}

onClickWidget kallas när en widget är klickade/berört
void onClickWidget (APWidget widget) {
String sendLetter = "";

Inaktivera de tidigare bakgrund färg växlare
foundDevice = false;
BTisConnected = false;

om (widget == whiteButton) {//if klickade på den röda knappen
buttonText = "white";
bakgrund (0, 255, 100);
sendLetter = "a";
}
annat if(widget == pinkButton) {
buttonText = "Rosa";
bakgrund (0, 200,200);
sendLetter = "b";
}
annars om (widget == redOrangeButton) {//if klickade på den blå knappen
buttonText = "Röd Orange";
bakgrund (255, 90, 0);
sendLetter = "c".
}
annars om (widget == blueButton) {//if klickade på off knappen
buttonText = "Blå";
Background(50,100,155);
sendLetter = "d";
}

byte [] myByte = stringToBytesUTFCustom(sendLetter);
sendReceiveBT.write(myByte);
}

När du har all denna kod körs, bör du kunna trycka på knapparna på app att ändra färgen på LED strips. Obs: Om telefonen är inaktiv för länge, förlorar du bluetooth-anslutning och du bör stänga app på telefonen och dra lätt styrelsen. Du kan sedan koppla in styrelsen igen och återuppta app och den ska ansluta igen.