Data Firmware

Control Arduino Genuino 101 onboard LED from Android iOS via Bluetooth Low Energy BLE

From Arduino IDE with Arduino/Genuino 101 board installed, its a CallbackLED example to test Arduino/Genuino 101 Bluetooth Low Energy (BLE) capabilities to turn on and of the LED connected to Pin 13 from a Android or iOS.


In Arduino IDE, open and download the CallbackLED example:
- File > Examples > CurieBLE > CallbackLED

CallbackLED.ino

/*
 Copyright (c) 2015 Intel Corporation. All rights reserved.

 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) any later version.

 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-
 1301 USA
*/


#include <CurieBLE.h>

const int ledPin = 13; // set ledPin to use on-board LED
BLEPeripheral blePeripheral; // create peripheral instance

BLEService ledService("19B10000-E8F2-537E-4F6C-D104768A1214"); // create service

// create switch characteristic and allow remote device to read and write
BLECharCharacteristic switchChar("19B10001-E8F2-537E-4F6C-D104768A1214", BLERead | BLEWrite);

void setup() {
 Serial.begin(9600);
 pinMode(ledPin, OUTPUT); // use the LED on pin 13 as an output

 // set the local name peripheral advertises
 blePeripheral.setLocalName("LEDCB");
 // set the UUID for the service this peripheral advertises
 blePeripheral.setAdvertisedServiceUuid(ledService.uuid());

 // add service and characteristic
 blePeripheral.addAttribute(ledService);
 blePeripheral.addAttribute(switchChar);

 // assign event handlers for connected, disconnected to peripheral
 blePeripheral.setEventHandler(BLEConnected, blePeripheralConnectHandler);
 blePeripheral.setEventHandler(BLEDisconnected, blePeripheralDisconnectHandler);

 // assign event handlers for characteristic
 switchChar.setEventHandler(BLEWritten, switchCharacteristicWritten);
// set an initial value for the characteristic
 switchChar.setValue(0);

 // advertise the service
 blePeripheral.begin();
 Serial.println(("Bluetooth device active, waiting for connections..."));
}

void loop() {
 // poll peripheral
 blePeripheral.poll();
}

void blePeripheralConnectHandler(BLECentral& central) {
 // central connected event handler
 Serial.print("Connected event, central: ");
 Serial.println(central.address());
}

void blePeripheralDisconnectHandler(BLECentral& central) {
 // central disconnected event handler
 Serial.print("Disconnected event, central: ");
 Serial.println(central.address());
}

void switchCharacteristicWritten(BLECentral& central, BLECharacteristic& characteristic) {
 // central wrote new value to characteristic, update LED
 Serial.print("Characteristic event, written: ");

 if (switchChar.value()) {
 Serial.println("LED on");
 digitalWrite(ledPin, HIGH);
 } else {
 Serial.println("LED off");
 digitalWrite(ledPin, LOW);
 }
}

On smartphone with BLE, download "nRF Master Control Panel (BLE)" app:
nRF Master Control Panel is a powerful generic tool that allows you to scan, advertise and explore your Bluetooth Smart (BLE) devices and communicate with them. nRF MCP supports number of Bluetooth SIG adopted profiles including Device Firmware Update profile (DFU) from Nordic Semiconductors.
- Android
- iOS


reference: http://www.arduino.cc/en/Tutorial/Genuino101CurieBLECallbackLED

Get

Example of using jSSC communicate between JavaFX and Arduino Uno via USB Serial port

Prepare a simple sketch run on Arduino Uno to send a counting number to serial port, tested on Windows 10.

BlinkUSB.ino

/*
 * Send number to Serial
 */
int i = 0;

// the setup function runs once when you press reset or power the board
void setup() {
 // initialize digital pin 13 as an output.
 pinMode(13, OUTPUT);
 Serial.begin(9600);
}

// the loop function runs over and over again forever
void loop() {

 Serial.print(i);
 i++;
 
 digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)
 delay(1000); // wait for a second
 digitalWrite(13, LOW); // turn the LED off by making the voltage LOW
 delay(1000); // wait for a second
}

Read last post to "Prepare jSSC - download and add library to NetBeans, and create project using jSSC library".

modify the java code, JavaFX_jssc_Uno.java

/*
 * Example of using jSSC library to handle serial port
 * Receive number from Arduino via USB/Serial and display on Label
 */
package javafx_jssc_uno;

import java.util.logging.Level;
import java.util.logging.Logger;
import javafx.application.Application;
import javafx.application.Platform;
import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableValue;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.scene.Scene;
import javafx.scene.control.ComboBox;
import javafx.scene.control.Label;
import javafx.scene.layout.StackPane;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;
import jssc.SerialPort;
import static jssc.SerialPort.MASK_RXCHAR;
import jssc.SerialPortEvent;
import jssc.SerialPortException;
import jssc.SerialPortList;

public class JavaFX_jssc_Uno extends Application {
 
 SerialPort arduinoPort = null;
 ObservableList<String> portList;
 
 Label labelValue;
 
 private void detectPort(){
 
 portList = FXCollections.observableArrayList();
 
 String[] serialPortNames = SerialPortList.getPortNames();
 for(String name: serialPortNames){
 System.out.println(name);
 portList.add(name);
 }
 }
 
 @Override
 public void start(Stage primaryStage) {
 
 labelValue = new Label();
 
 detectPort();
 final ComboBox comboBoxPorts = new ComboBox(portList);
 comboBoxPorts.valueProperty()
 .addListener(new ChangeListener<String>() {

 @Override
 public void changed(ObservableValue<? extends String> observable, 
 String oldValue, String newValue) {

 System.out.println(newValue);
 disconnectArduino();
 connectArduino(newValue);
 }

 });
 
 VBox vBox = new VBox();
 vBox.getChildren().addAll(
 comboBoxPorts, labelValue);
 
 StackPane root = new StackPane();
 root.getChildren().add(vBox);
 
 Scene scene = new Scene(root, 300, 250);
 
 primaryStage.setTitle("Hello World!");
 primaryStage.setScene(scene);
 primaryStage.show();
 }

 public boolean connectArduino(String port){
 
 System.out.println("connectArduino");
 
 boolean success = false;
 SerialPort serialPort = new SerialPort(port);
 try {
 serialPort.openPort();
 serialPort.setParams(
 SerialPort.BAUDRATE_9600,
 SerialPort.DATABITS_8,
 SerialPort.STOPBITS_1,
 SerialPort.PARITY_NONE);
 serialPort.setEventsMask(MASK_RXCHAR);
 serialPort.addEventListener((SerialPortEvent serialPortEvent) -> {
 if(serialPortEvent.isRXCHAR()){
 try {
 String st = serialPort.readString(serialPortEvent
 .getEventValue());
 System.out.println(st);
 
 //Update label in ui thread
 Platform.runLater(() -> {
 labelValue.setText(st);
 });
 
 } catch (SerialPortException ex) {
 Logger.getLogger(JavaFX_jssc_Uno.class.getName())
 .log(Level.SEVERE, null, ex);
 }
 
 }
 });
 
 arduinoPort = serialPort;
 success = true;
 } catch (SerialPortException ex) {
 Logger.getLogger(JavaFX_jssc_Uno.class.getName())
 .log(Level.SEVERE, null, ex);
 System.out.println("SerialPortException: " + ex.toString());
 }

 return success;
 }
 
 public void disconnectArduino(){
 
 System.out.println("disconnectArduino()");
 if(arduinoPort != null){
 try {
 arduinoPort.removeEventListener();
 
 if(arduinoPort.isOpened()){
 arduinoPort.closePort();
 }
 
 } catch (SerialPortException ex) {
 Logger.getLogger(JavaFX_jssc_Uno.class.getName())
 .log(Level.SEVERE, null, ex);
 }
 }
 }

 @Override
 public void stop() throws Exception {
 disconnectArduino();
 super.stop();
 }
 
 public static void main(String[] args) {
 launch(args);
 }
 
}

Next:
- JavaFX + jSSC - read byte from Arduino Uno, read from Analog Input

Get

Arduino Uno MAX7219 8x8 LED Matrix via SPI using LedControl Library

We can add LedControl Library to Arduino IDE, to control 8*8 LED Matrix with MAX7219 via SPI. LedControl is a library for the MAX7219 and the MAX7221 Led display driver.
(ref: http://wayoda.github.io/LedControl/)


Open the File > Examples > LedControl > LCDemoMatrix

LCDemoMatrix.ino

//We always have to include the library
#include "LedControl.h"

/*
 Now we need a LedControl to work with.
 ***** These pin numbers will probably not work with your hardware *****
 pin 12 is connected to the DataIn 
 pin 11 is connected to the CLK 
 pin 10 is connected to LOAD 
 We have only a single MAX72XX.
 */
LedControl lc=LedControl(12,11,10,1);

/* we always wait a bit between updates of the display */
unsigned long delaytime=100;

void setup() {
 /*
 The MAX72XX is in power-saving mode on startup,
 we have to do a wakeup call
 */
 lc.shutdown(0,false);
 /* Set the brightness to a medium values */
 lc.setIntensity(0,8);
 /* and clear the display */
 lc.clearDisplay(0);
}

/*
 This method will display the characters for the
 word "Arduino" one after the other on the matrix. 
 (you need at least 5x7 leds to see the whole chars)
 */
void writeArduinoOnMatrix() {
 /* here is the data for the characters */
 byte a[5]={B01111110,B10001000,B10001000,B10001000,B01111110};
 byte r[5]={B00111110,B00010000,B00100000,B00100000,B00010000};
 byte d[5]={B00011100,B00100010,B00100010,B00010010,B11111110};
 byte u[5]={B00111100,B00000010,B00000010,B00000100,B00111110};
 byte i[5]={B00000000,B00100010,B10111110,B00000010,B00000000};
 byte n[5]={B00111110,B00010000,B00100000,B00100000,B00011110};
 byte o[5]={B00011100,B00100010,B00100010,B00100010,B00011100};

 /* now display them one by one with a small delay */
 lc.setRow(0,0,a[0]);
 lc.setRow(0,1,a[1]);
 lc.setRow(0,2,a[2]);
 lc.setRow(0,3,a[3]);
 lc.setRow(0,4,a[4]);
 delay(delaytime);
 lc.setRow(0,0,r[0]);
 lc.setRow(0,1,r[1]);
 lc.setRow(0,2,r[2]);
 lc.setRow(0,3,r[3]);
 lc.setRow(0,4,r[4]);
 delay(delaytime);
 lc.setRow(0,0,d[0]);
 lc.setRow(0,1,d[1]);
 lc.setRow(0,2,d[2]);
 lc.setRow(0,3,d[3]);
 lc.setRow(0,4,d[4]);
 delay(delaytime);
 lc.setRow(0,0,u[0]);
 lc.setRow(0,1,u[1]);
 lc.setRow(0,2,u[2]);
 lc.setRow(0,3,u[3]);
 lc.setRow(0,4,u[4]);
 delay(delaytime);
 lc.setRow(0,0,i[0]);
 lc.setRow(0,1,i[1]);
 lc.setRow(0,2,i[2]);
 lc.setRow(0,3,i[3]);
 lc.setRow(0,4,i[4]);
 delay(delaytime);
 lc.setRow(0,0,n[0]);
 lc.setRow(0,1,n[1]);
 lc.setRow(0,2,n[2]);
 lc.setRow(0,3,n[3]);
 lc.setRow(0,4,n[4]);
 delay(delaytime);
 lc.setRow(0,0,o[0]);
 lc.setRow(0,1,o[1]);
 lc.setRow(0,2,o[2]);
 lc.setRow(0,3,o[3]);
 lc.setRow(0,4,o[4]);
 delay(delaytime);
 lc.setRow(0,0,0);
 lc.setRow(0,1,0);
 lc.setRow(0,2,0);
 lc.setRow(0,3,0);
 lc.setRow(0,4,0);
 delay(delaytime);
}

/*
 This function lights up a some Leds in a row.
 The pattern will be repeated on every row.
 The pattern will blink along with the row-number.
 row number 4 (index==3) will blink 4 times etc.
 */
void rows() {
 for(int row=0;row<8;row++) {
 delay(delaytime);
 lc.setRow(0,row,B10100000);
 delay(delaytime);
 lc.setRow(0,row,(byte)0);
 for(int i=0;i<row;i++) {
 delay(delaytime);
 lc.setRow(0,row,B10100000);
 delay(delaytime);
 lc.setRow(0,row,(byte)0);
 }
 }
}

/*
 This function lights up a some Leds in a column.
 The pattern will be repeated on every column.
 The pattern will blink along with the column-number.
 column number 4 (index==3) will blink 4 times etc.
 */
void columns() {
 for(int col=0;col<8;col++) {
 delay(delaytime);
 lc.setColumn(0,col,B10100000);
 delay(delaytime);
 lc.setColumn(0,col,(byte)0);
 for(int i=0;i<col;i++) {
 delay(delaytime);
 lc.setColumn(0,col,B10100000);
 delay(delaytime);
 lc.setColumn(0,col,(byte)0);
 }
 }
}

/* 
 This function will light up every Led on the matrix.
 The led will blink along with the row-number.
 row number 4 (index==3) will blink 4 times etc.
 */
void single() {
 for(int row=0;row<8;row++) {
 for(int col=0;col<8;col++) {
 delay(delaytime);
 lc.setLed(0,row,col,true);
 delay(delaytime);
 for(int i=0;i<col;i++) {
 lc.setLed(0,row,col,false);
 delay(delaytime);
 lc.setLed(0,row,col,true);
 delay(delaytime);
 }
 }
 }
}

void loop() { 
 writeArduinoOnMatrix();
 rows();
 columns();
 single();
}

Connect MAX7219 8x8 LED Matrix to Arduino Uno as stated in the example:
- pin 12 is connected to the DataIn
- pin 11 is connected to the CLK
- pin 10 is connected to LOAD (its cs marked on my sample)
- +5V to VCC
- GND to GND


Run.

Check the video:

Get