2Down vote

To fix your speaker problem - Go to Settings > Bluetooth > Turn On and wait for your list of
devices to populate. Locate your speaker and Long Press it (press and hold) and then
select Un-pair. You'll be free to attempt to pair it again with the proper PIN!
If your device isn't paired with the phone, but it's still not connecting, you can try clearing
your Bluetooth cache. Turn off Bluetooth, then Go to Settings > Applications > All > Bluetooth Share
and tap "Force Stop," then "Clear Cache," then "Clear Data. If the device was ever paired or a pairing
ever failed, it may have stored those credentials regardless of success. This should give
you a fresh chance at it.
As for why you can't specify what PIN your speaker provides your phone - it's because the
default PIN is assigned to the device when it's made, and can't be changed by the average
consumer. Most 'dumb' Bluetooth devices have no way of changing the PIN it comes with.

Programming 8x8 LED Matrix

Sending Bytes to an 8x8 LED Matrix.

art

lights

374,099  VIEWS

67  COMMENTS

310  RESPECTS

COMPONENTS AND SUPPLIES

Jumper wires
× 16
(generic)

Breadboard
× 2
(generic)
 Arduino UNO × 1

Adafruit 8x8
× 1
LED Matrix

Adafruit USB
Cable -
× 1
Standard A-B
for ARDUINO

APPS AND ONLINE SERVICES

Arduino IDE

ABOUT THIS PROJECT

This is a very easy project for starters like me, the idea of it is to show you how to send bytes to an 8x8
LED matrix.

I have programmed this with all the letters of the alphabet,if you wish to add something go
HERE: http://robojax.com/learn/arduino/8x8LED/

In that link you will be able to make more shapes.

In the left hand part of the page there will be an 8x8 matrix, with all the Leds off, by clicking them they
will turn on and at the bottom of the page there will be the code that represents what you are doing to
the matrix, when finished change the "sprite name " and paste the code that you just made, in the code
that I made.

To make this project work you will need the library:

FrequencyTimer2

Which you can download from:

https://github.com/rookie/FrequencyTimer2

Programming 8x8 LED Matrix

Sending Bytes to an 8x8 LED Matrix.

art
lights

374,099  VIEWS

67  COMMENTS

310  RESPECTS

COMPONENTS AND SUPPLIES

Jumper wires
× 16
(generic)

Breadboard
× 2
(generic)

Arduino UNO × 1

Adafruit 8x8
× 1
LED Matrix

Adafruit USB
Cable -
× 1
Standard A-B
for ARDUINO

APPS AND ONLINE SERVICES

Arduino IDE

ABOUT THIS PROJECT

This is a very easy project for starters like me, the idea of it is to show you how to send bytes to an 8x8
LED matrix.

I have programmed this with all the letters of the alphabet,if you wish to add something go
HERE: http://robojax.com/learn/arduino/8x8LED/

In that link you will be able to make more shapes.

In the left hand part of the page there will be an 8x8 matrix, with all the Leds off, by clicking them they
will turn on and at the bottom of the page there will be the code that represents what you are doing to
the matrix, when finished change the "sprite name " and paste the code that you just made, in the code
that I made.

To make this project work you will need the library:

FrequencyTimer2
Which you can download from:

https://github.com/rookie/FrequencyTimer2

CODE
Here's the codeArduino
//update from SAnwandter

#define ROW_1 2

#define ROW_2 3

#define ROW_3 4

#define ROW_4 5

#define ROW_5 6

#define ROW_6 7

#define ROW_7 8

#define ROW_8 9

#define COL_1 10

#define COL_2 11

#define COL_3 12

#define COL_4 13

#define COL_5 A0

#define COL_6 A1

#define COL_7 A2

#define COL_8 A3

const byte rows[] = {

ROW_1, ROW_2, ROW_3, ROW_4, ROW_5, ROW_6, ROW_7, ROW_8

};

const byte col[] = {

 COL_1,COL_2, COL_3, COL_4, COL_5, COL_6, COL_7, COL_8

};

// The display buffer

// It's prefilled with a smiling face (1 = ON, 0 = OFF)

byte ALL[] = {B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111};

byte EX[] = {B00000000,B00010000,B00010000,B00010000,B00010000,B00000000,B00010000,B00000000};

byte A[] = { B00000000,B00111100,B01100110,B01100110,B01111110,B01100110,B01100110,B01100110};

byte B[] = {B01111000,B01001000,B01001000,B01110000,B01001000,B01000100,B01000100,B01111100};

byte C[] = {B00000000,B00011110,B00100000,B01000000,B01000000,B01000000,B00100000,B00011110};

byte D[] = {B00000000,B00111000,B00100100,B00100010,B00100010,B00100100,B00111000,B00000000};

byte E[] = {B00000000,B00111100,B00100000,B00111000,B00100000,B00100000,B00111100,B00000000};

byte F[] = {B00000000,B00111100,B00100000,B00111000,B00100000,B00100000,B00100000,B00000000};

byte G[] = {B00000000,B00111110,B00100000,B00100000,B00101110,B00100010,B00111110,B00000000};

byte H[] = {B00000000,B00100100,B00100100,B00111100,B00100100,B00100100,B00100100,B00000000};

byte I[] = {B00000000,B00111000,B00010000,B00010000,B00010000,B00010000,B00111000,B00000000};

byte J[] = {B00000000,B00011100,B00001000,B00001000,B00001000,B00101000,B00111000,B00000000};

byte K[] = {B00000000,B00100100,B00101000,B00110000,B00101000,B00100100,B00100100,B00000000};

byte L[] = {B00000000,B00100000,B00100000,B00100000,B00100000,B00100000,B00111100,B00000000};

byte M[] = {B00000000,B00000000,B01000100,B10101010,B10010010,B10000010,B10000010,B00000000};

byte N[] = {B00000000,B00100010,B00110010,B00101010,B00100110,B00100010,B00000000,B00000000};

byte O[] = {B00000000,B00111100,B01000010,B01000010,B01000010,B01000010,B00111100,B00000000};

byte P[] = {B00000000,B00111000,B00100100,B00100100,B00111000,B00100000,B00100000,B00000000};

byte Q[] = {B00000000,B00111100,B01000010,B01000010,B01000010,B01000110,B00111110,B00000001};

byte R[] = {B00000000,B00111000,B00100100,B00100100,B00111000,B00100100,B00100100,B00000000};

byte S[] = {B00000000,B00111100,B00100000,B00111100,B00000100,B00000100,B00111100,B00000000};

byte T[] = {B00000000,B01111100,B00010000,B00010000,B00010000,B00010000,B00010000,B00000000};

byte U[] = {B00000000,B01000010,B01000010,B01000010,B01000010,B00100100,B00011000,B00000000};

byte V[] = {B00000000,B00100010,B00100010,B00100010,B00010100,B00010100,B00001000,B00000000};

byte W[] = {B00000000,B10000010,B10010010,B01010100,B01010100,B00101000,B00000000,B00000000};

byte X[] = {B00000000,B01000010,B00100100,B00011000,B00011000,B00100100,B01000010,B00000000};

byte Y[] = {B00000000,B01000100,B00101000,B00010000,B00010000,B00010000,B00010000,B00000000};

byte Z[] = {B00000000,B00111100,B00000100,B00001000,B00010000,B00100000,B00111100,B00000000};

float timeCount = 0;

void setup()

// Open serial port

Serial.begin(9600);

// Set all used pins to OUTPUT

// This is very important! If the pins are set to input

// the display will be very dim.

for (byte i = 2; i <= 13; i++)

pinMode(i, OUTPUT);

pinMode(A0, OUTPUT);

pinMode(A1, OUTPUT);

pinMode(A2, OUTPUT);

pinMode(A3, OUTPUT);

void loop() {

// This could be rewritten to not use a delay, which would make it appear brighter

delay(5);

timeCount += 1;
if(timeCount < 20)

drawScreen(A);

else if (timeCount < 40)

drawScreen(R);

else if (timeCount < 60)

drawScreen(D);

else if (timeCount < 80)

drawScreen(U);

else if (timeCount < 100)

drawScreen(I);

else if (timeCount < 120)

drawScreen(N);

else if (timeCount < 140) {

drawScreen(O);

}
else if (timeCount < 160)

drawScreen(ALL);

else if (timeCount < 180)

drawScreen(ALL);

else {

// back to the start

timeCount = 0;

void drawScreen(byte buffer2[])

// Turn on each row in series

for (byte i = 0; i < 8; i++) // count next row

digitalWrite(rows[i], HIGH); //initiate whole row

for (byte a = 0; a < 8; a++) // count next row

// if You set (~buffer2[i] >> a) then You will have positive

digitalWrite(col[a], (buffer2[i] >> a) & 0x01); // initiate whole column

delayMicroseconds(100); // uncoment deley for diferent speed of display

//delayMicroseconds(1000);

//delay(10);

//delay(100);
 digitalWrite(col[a], 1); // reset whole column

digitalWrite(rows[i], LOW); // reset whole row

// otherwise last row will intersect with next row

//

/* this is siplest resemplation how for loop is working with each row.

digitalWrite(COL_1, (~b >> 0) & 0x01); // Get the 1st bit: 10000000

digitalWrite(COL_2, (~b >> 1) & 0x01); // Get the 2nd bit: 01000000

digitalWrite(COL_3, (~b >> 2) & 0x01); // Get the 3rd bit: 00100000

digitalWrite(COL_4, (~b >> 3) & 0x01); // Get the 4th bit: 00010000

digitalWrite(COL_5, (~b >> 4) & 0x01); // Get the 5th bit: 00001000

digitalWrite(COL_6, (~b >> 5) & 0x01); // Get the 6th bit: 00000100

digitalWrite(COL_7, (~b >> 6) & 0x01); // Get the 7th bit: 00000010

digitalWrite(COL_8, (~b >> 7) & 0x01); // Get the 8th bit: 00000001
}*/