can I ask for help, why is the word STOP STOP STOP STOP is not sending at the MAX7219 when the high magnetic field is detected by the Hall Effect,
https://pastecode.io/s/5bqmtmko
here's a diagram as well (Dont mind the SIM808)
can I ask for help, why is the word STOP STOP STOP STOP is not sending at the MAX7219 when the high magnetic field is detected by the Hall Effect,
https://pastecode.io/s/5bqmtmko
here's a diagram as well (Dont mind the SIM808)
Welcome to the forum!
I'm sorry, but in your two hours reading since you joined, did you not have a chance to read this yet?
Please post your code in code tags; many of the best helpers here won't follow links to find your code, then copy it into their IDE. The fritzing diagram is better than most, but an attempt at a schematic would be more informative; document power connections, pin numbers, etc. Colored wires don't really do it for most of us. Descriptive text, or better, links to your actual devices, would be useful. Some description of what your project is supposed to be doing might help us see what's going on in your code much more quickly.
Remember, the effort you put into communicating with us will influence both the speed with which you get answers, and the usefulness of those answers.
Welcome! Please read the forum guidelines, they help us help you and generally faster and better answers. Guidelines: Please read the advice in the topic "How to get the best from this forum". How to get the best out of this forum
I do not read screen shots even if they are in a link. Diagrams should show what we are talking, when I see (Dont mind the SIM808) that indicates it is a copy, of somebody else project not what you built. I do not work well with frizzes or word programs but prefer a real annotated schematic as do many others.
Will this be more appropriate
Code for MPU6050 to make left or right turn and send it at the MAX7219:
#include "LedControl.h"
#include <Wire.h>
#include <MPU6050.h>
LedControl lc = LedControl(51, 52, 53, 4); // Pins: DIN, CLK, CS, # of Displays connected
MPU6050 mpu;
unsigned long delayTime = 200; // Delay between Frames
// Put values in arrays
byte invader1a[] =
{
B00010010, // First frame of invader #1
B00100100,
B01001001,
B10010010,
B10010010,
B01001001,
B00100100,
B00010010};
byte invader1b[] =
{
B00000000, // Second frame of invader #1
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000};
byte invader2a[] =
{
B00010010, // First frame of invader #1
B00100100,
B01001001,
B10010010,
B10010010,
B01001001,
B00100100,
B00010010};
byte invader2b[] =
{
B00000000, // Second frame of invader #2 (flipped horizontally)
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000};
byte invader3a[] =
{
B00010010, // First frame of invader #1
B00100100,
B01001001,
B10010010,
B10010010,
B01001001,
B00100100,
B00010010};;
byte invader3b[] =
{
B00000000, // First frame of invader #2 (flipped horizontally)
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000};
byte invader4a[] =
{
B00010010, // First frame of invader #1
B00100100,
B01001001,
B10010010,
B10010010,
B01001001,
B00100100,
B00010010};
byte invader4b[] =
{
B00000000, // Second frame of invader #2
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000};
// Put values in arrays
byte invader1c[] =
{
B01001000, // First frame of invader #1
B00100100,
B10010010,
B01001001,
B01001001,
B10010010,
B00100100,
B01001000};
byte invader1d[] =
{
B00000000, // Second frame of invader #1
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000};
byte invader2c[] =
{
B01001000, // First frame of invader #1
B00100100,
B10010010,
B01001001,
B01001001,
B10010010,
B00100100,
B01001000};
byte invader2d[] =
{
B00000000, // Second frame of invader #2 (flipped horizontally)
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000};
byte invader3c[] =
{
B01001000, // First frame of invader #1
B00100100,
B10010010,
B01001001,
B01001001,
B10010010,
B00100100,
B01001000};
byte invader3d[] =
{
B00000000, // First frame of invader #2 (flipped horizontally)
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000};
byte invader4c[] =
{
B01001000, // First frame of invader #1
B00100100,
B10010010,
B01001001,
B01001001,
B10010010,
B00100100,
B01001000};
byte invader4d[] =
{
B00000000, // Second frame of invader #2
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000};
void setup()
{
lc.shutdown(0, false); // Wake up displays
lc.shutdown(1, false);
lc.shutdown(2, false);
lc.shutdown(3, false);
lc.setIntensity(0, 5); // Set intensity levels
lc.setIntensity(1, 5);
lc.setIntensity(2, 5);
lc.setIntensity(3, 5);
lc.clearDisplay(0); // Clear Displays
lc.clearDisplay(1);
lc.clearDisplay(2);
lc.clearDisplay(3);
Wire.begin();
mpu.initialize();
}
void loop()
{
int16_t ax, ay, az;
mpu.getAcceleration(&ax, &ay, &az);
// Detect tilt direction
if (ax > 10000) // Tilt to the right
{
// Put #1 frame on both Displays
sinvader1a();
delay(delayTime);
sinvader2a();
delay(delayTime);
// Put #2 frame on both Displays
sinvader3a();
delay(delayTime);
sinvader4a();
delay(delayTime);
// Put #3 frame on both Displays
sinvader1b();
delay(delayTime);
sinvader2b();
delay(delayTime);
// Put #4 frame on both Displays
sinvader3b();
delay(delayTime);
sinvader4b();
delay(delayTime);
}
else if (ax < -10000) // Tilt to the left
{
// Put #1 frame on both Displays
sinvader4c();
delay(delayTime);
sinvader3c();
delay(delayTime);
// Put #2 frame on both Displays
sinvader2c();
delay(delayTime);
sinvader1c();
delay(delayTime);
// Put #3 frame on both Displays
sinvader4d();
delay(delayTime);
sinvader3d();
delay(delayTime);
// Put #4 frame on both Displays
sinvader2d();
delay(delayTime);
sinvader1d();
delay(delayTime);
}
}
// Take values in Arrays and Display them
void sinvader1a()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(0, i, invader1a[i]);
}
}
void sinvader1b()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(0, i, invader1b[i]);
}
}
void sinvader2a()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(1, i, invader2a[i]);
}
}
void sinvader2b()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(1, i, invader2b[i]);
}
}
void sinvader3a()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(2, i, invader3a[i]);
}
}
void sinvader3b()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(2, i, invader3b[i]);
}
}
void sinvader4a()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(3, i, invader4a[i]);
}
}
void sinvader4b()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(3, i, invader4b[i]);
}
}
void sinvader4c()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(3, i, invader4c[i]);
}
}
void sinvader3c()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(2, i, invader3c[i]);
}
}
void sinvader2c()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(1, i, invader2c[i]);
}
}
void sinvader1c()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(0, i, invader1c[i]);
}
}
void sinvader4d()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(3, i, invader4d[i]);
}
}
void sinvader3d()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(2, i, invader3d[i]);
}
}
void sinvader2d()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(1, i, invader2d[i]);
}
}
void sinvader1d()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(0, i, invader1d[i]);
}
}
Coding for Hall Effect to send STOP STOP at the MAX7219 when it receives high magnetic field and clear the display when the magnetic field is decreasing (low):
#include <MD_Parola.h>
#include <MD_MAX72xx.h>
#include <SPI.h>
#define MAX_DEVICES 4
#define HARDWARE_TYPE MD_MAX72XX::PAROLA_HW
#define CLK_PIN 52
#define DATA_PIN 51
#define CS_PIN 53
int hallSensorPin = 2;
volatile bool sensorTriggered = false;
MD_Parola myDisplay = MD_Parola(MD_MAX72XX::FC16_HW, CS_PIN, MAX_DEVICES);
void sensorInterrupt() {
sensorTriggered = !digitalRead(hallSensorPin); // Read the sensor state in the interrupt
}
void setup() {
myDisplay.begin();
myDisplay.setIntensity(8);
myDisplay.displayClear();
pinMode(hallSensorPin, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(hallSensorPin), sensorInterrupt, FALLING); // Attach interrupt on CHANGE
}
void loop() {
if (sensorTriggered) {
myDisplay.displayScroll("STOP STOP STOP STOP ", PA_CENTER, PA_SCROLL_RIGHT, 30);
sensorTriggered = false;
}
if (myDisplay.displayAnimate()) {
myDisplay.displayClear();
}
}
I also provided a picture of schematic
can I ask for help, why is the word STOP STOP STOP STOP is not sending at the MAX7219 when the high magnetic field is detected by the Hall Effect,
Can you make the MAX7219 show anything at all?
Can you verify that your Hall sensor can detect a magnetic field?
Can you accomplish this all, when all components are connected as in your image?
To solve your problem, you have to simply break down everything into smaller steps, which you make work. And slowly build up everything.
Simply put: The Hall sensor is your input, the MAX7219 is your output. Make your output work. Make your input work. Make your logic work, which make the output act correctly.
In terms of making the MAX7219 show anything at all, yes I can, but when I run the 2 separate codes only, but when I tried combining both of this code its not sending anything at the MAX7219. Also I can verify that the Hall sensor can detect a magnetic field, it lights up a led whenever it detected a high magnetic field and turns off the led when not so I guarantee that it is detecting a magnetic field.
You need to tilt the MPU. These two lines above say...
DISPLAY INVADER | -10,000 <== DO NOTHING ==> 10,000 | DISPLAY INVADER
Isnt it the same? Wont it work the same as the one I provided? Thanks for responding btw
Yes, your post and my post are the same thing. Your code says "do nothing from -10000 to +10000. What are the "ax" values when nominal? When active in the "x" direction?
This is your code with some additional serial printing
It is originally your logic I added these lines
int rangeOfAX = 0; // initialise indicating variable with ZERO
if (ax > 10000) // Tilt to the right
{
rangeOfAX = 11000; // set indicating variable to a high positiv value
// Put #1 frame on both Displays
sinvader1a();
else if (ax < -10000) // Tilt to the left
{
rangeOfAX = -19000; // set indicating variable to a very negative value
// Put #1 frame on both Displays
sinvader4c();
// print in which range the indicating variable is
if (rangeOfAX == -19000) {
Serial.println("HIGH negative values of ax");
}
if (rangeOfAX == 11000) {
Serial.println("HIGH POSITIVE values of ax");
}
if (rangeOfAX == 0) {
Serial.println("range of ax between -10000 and + 10000");
}
This will make visible what is going on
#include "LedControl.h"
#include <Wire.h>
#include <MPU6050.h>
LedControl lc = LedControl(51, 52, 53, 4); // Pins: DIN, CLK, CS, # of Displays connected
MPU6050 mpu;
unsigned long delayTime = 200; // Delay between Frames
// Put values in arrays
byte invader1a[] =
{
B00010010, // First frame of invader #1
B00100100,
B01001001,
B10010010,
B10010010,
B01001001,
B00100100,
B00010010
};
byte invader1b[] =
{
B00000000, // Second frame of invader #1
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000
};
byte invader2a[] =
{
B00010010, // First frame of invader #1
B00100100,
B01001001,
B10010010,
B10010010,
B01001001,
B00100100,
B00010010
};
byte invader2b[] =
{
B00000000, // Second frame of invader #2 (flipped horizontally)
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000
};
byte invader3a[] =
{
B00010010, // First frame of invader #1
B00100100,
B01001001,
B10010010,
B10010010,
B01001001,
B00100100,
B00010010
};;
byte invader3b[] =
{
B00000000, // First frame of invader #2 (flipped horizontally)
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000
};
byte invader4a[] =
{
B00010010, // First frame of invader #1
B00100100,
B01001001,
B10010010,
B10010010,
B01001001,
B00100100,
B00010010
};
byte invader4b[] =
{
B00000000, // Second frame of invader #2
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000
};
// Put values in arrays
byte invader1c[] =
{
B01001000, // First frame of invader #1
B00100100,
B10010010,
B01001001,
B01001001,
B10010010,
B00100100,
B01001000
};
byte invader1d[] =
{
B00000000, // Second frame of invader #1
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000
};
byte invader2c[] =
{
B01001000, // First frame of invader #1
B00100100,
B10010010,
B01001001,
B01001001,
B10010010,
B00100100,
B01001000
};
byte invader2d[] =
{
B00000000, // Second frame of invader #2 (flipped horizontally)
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000
};
byte invader3c[] =
{
B01001000, // First frame of invader #1
B00100100,
B10010010,
B01001001,
B01001001,
B10010010,
B00100100,
B01001000
};
byte invader3d[] =
{
B00000000, // First frame of invader #2 (flipped horizontally)
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000
};
byte invader4c[] =
{
B01001000, // First frame of invader #1
B00100100,
B10010010,
B01001001,
B01001001,
B10010010,
B00100100,
B01001000
};
byte invader4d[] =
{
B00000000, // Second frame of invader #2
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000
};
void setup()
{
lc.shutdown(0, false); // Wake up displays
lc.shutdown(1, false);
lc.shutdown(2, false);
lc.shutdown(3, false);
lc.setIntensity(0, 5); // Set intensity levels
lc.setIntensity(1, 5);
lc.setIntensity(2, 5);
lc.setIntensity(3, 5);
lc.clearDisplay(0); // Clear Displays
lc.clearDisplay(1);
lc.clearDisplay(2);
lc.clearDisplay(3);
Wire.begin();
mpu.initialize();
}
void loop()
{
int16_t ax, ay, az;
mpu.getAcceleration(&ax, &ay, &az);
int rangeOfAX = 0; // initialise indicating variable with ZERO
// Detect tilt direction
if (ax > 10000) // Tilt to the right
{
rangeOfAX = 11000; // set indicating variable to a high positiv value
// Put #1 frame on both Displays
sinvader1a();
delay(delayTime);
sinvader2a();
delay(delayTime);
// Put #2 frame on both Displays
sinvader3a();
delay(delayTime);
sinvader4a();
delay(delayTime);
// Put #3 frame on both Displays
sinvader1b();
delay(delayTime);
sinvader2b();
delay(delayTime);
// Put #4 frame on both Displays
sinvader3b();
delay(delayTime);
sinvader4b();
delay(delayTime);
}
else if (ax < -10000) // Tilt to the left
{
rangeOfAX = -19000; // set indicating variable to a very negative value
// Put #1 frame on both Displays
sinvader4c();
delay(delayTime);
sinvader3c();
delay(delayTime);
// Put #2 frame on both Displays
sinvader2c();
delay(delayTime);
sinvader1c();
delay(delayTime);
// Put #3 frame on both Displays
sinvader4d();
delay(delayTime);
sinvader3d();
delay(delayTime);
// Put #4 frame on both Displays
sinvader2d();
delay(delayTime);
sinvader1d();
delay(delayTime);
}
if (rangeOfAX == -19000) {
Serial.println("HIGH negative values of ax");
}
if (rangeOfAX == 11000) {
Serial.println("HIGH POSITIVE values of ax");
}
if (rangeOfAX == 0) {
Serial.println("range of ax between -10000 and + 10000");
}
}
// Take values in Arrays and Display them
void sinvader1a()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(0, i, invader1a[i]);
}
}
void sinvader1b()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(0, i, invader1b[i]);
}
}
void sinvader2a()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(1, i, invader2a[i]);
}
}
void sinvader2b()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(1, i, invader2b[i]);
}
}
void sinvader3a()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(2, i, invader3a[i]);
}
}
void sinvader3b()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(2, i, invader3b[i]);
}
}
void sinvader4a()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(3, i, invader4a[i]);
}
}
void sinvader4b()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(3, i, invader4b[i]);
}
}
void sinvader4c()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(3, i, invader4c[i]);
}
}
void sinvader3c()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(2, i, invader3c[i]);
}
}
void sinvader2c()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(1, i, invader2c[i]);
}
}
void sinvader1c()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(0, i, invader1c[i]);
}
}
void sinvader4d()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(3, i, invader4d[i]);
}
}
void sinvader3d()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(2, i, invader3d[i]);
}
}
void sinvader2d()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(1, i, invader2d[i]);
}
}
void sinvader1d()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(0, i, invader1d[i]);
}
}
When you have the display in scrolling-"STOP" mode you'll have work in a Hall check (which may make that a little less 'fluid'), depending on how responsive that's supposed to be.
I think your post answer your questions, its nominal between -10000 and 10000 and active whenever its x < -10000 and x > 10000
Ive tried running the code, however it wont display the right and left turn signal and also the value of x, y, and z of the MPU6050 is not in the serial monitor. So theres no way for me to tell if im actually able to achieve those values.
Can you enlighten me, I'm new to coding and my knowledge about this is not that broad, Im trying my best to understand all of your recommendations, thanks for responsing
Heres an updated code, Im trying to fix it but the only one working is the Hall effect it does display the STOP STOP at the MAX7219 but it is so slow, and still the MPU6050 is not working nor it display the ax, ay, and az value at the serial monitor.
#include "LedControl.h"
#include <Wire.h>
#include <MPU6050.h>
//Begin STOP STOP Hall Effect
#include <MD_Parola.h>
#include <MD_MAX72xx.h>
#include <SPI.h>
#define MAX_DEVICES 4
#define HARDWARE_TYPE MD_MAX72XX::PAROLA_HW
#define CLK_PIN 52
#define DATA_PIN 51
#define CS_PIN 53
int hallSensorPin = 2;
volatile bool sensorTriggered = false;
MD_Parola myDisplay = MD_Parola(MD_MAX72XX::FC16_HW, CS_PIN, MAX_DEVICES);
void sensorInterrupt() {
sensorTriggered = !digitalRead(hallSensorPin); // Read the sensor state in the interrupt
}
LedControl lc = LedControl(51, 52, 53, 4); // Pins: DIN, CLK, CS, # of Displays connected
MPU6050 mpu;
unsigned long delayTime = 200; // Delay between Frames
// Put values in arrays
byte invader1a[] =
{
B00010010, // First frame of invader #1
B00100100,
B01001001,
B10010010,
B10010010,
B01001001,
B00100100,
B00010010};
byte invader1b[] =
{
B00000000, // Second frame of invader #1
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000};
byte invader2a[] =
{
B00010010, // First frame of invader #1
B00100100,
B01001001,
B10010010,
B10010010,
B01001001,
B00100100,
B00010010};
byte invader2b[] =
{
B00000000, // Second frame of invader #2 (flipped horizontally)
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000};
byte invader3a[] =
{
B00010010, // First frame of invader #1
B00100100,
B01001001,
B10010010,
B10010010,
B01001001,
B00100100,
B00010010};;
byte invader3b[] =
{
B00000000, // First frame of invader #2 (flipped horizontally)
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000};
byte invader4a[] =
{
B00010010, // First frame of invader #1
B00100100,
B01001001,
B10010010,
B10010010,
B01001001,
B00100100,
B00010010};
byte invader4b[] =
{
B00000000, // Second frame of invader #2
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000};
// Put values in arrays
byte invader1c[] =
{
B01001000, // First frame of invader #1
B00100100,
B10010010,
B01001001,
B01001001,
B10010010,
B00100100,
B01001000};
byte invader1d[] =
{
B00000000, // Second frame of invader #1
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000};
byte invader2c[] =
{
B01001000, // First frame of invader #1
B00100100,
B10010010,
B01001001,
B01001001,
B10010010,
B00100100,
B01001000};
byte invader2d[] =
{
B00000000, // Second frame of invader #2 (flipped horizontally)
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000};
byte invader3c[] =
{
B01001000, // First frame of invader #1
B00100100,
B10010010,
B01001001,
B01001001,
B10010010,
B00100100,
B01001000};
byte invader3d[] =
{
B00000000, // First frame of invader #2 (flipped horizontally)
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000};
byte invader4c[] =
{
B01001000, // First frame of invader #1
B00100100,
B10010010,
B01001001,
B01001001,
B10010010,
B00100100,
B01001000};
byte invader4d[] =
{
B00000000, // Second frame of invader #2
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000};
void setup()
{
lc.shutdown(0, false); // Wake up displays
lc.shutdown(1, false);
lc.shutdown(2, false);
lc.shutdown(3, false);
lc.setIntensity(0, 5); // Set intensity levels
lc.setIntensity(1, 5);
lc.setIntensity(2, 5);
lc.setIntensity(3, 5);
lc.clearDisplay(0); // Clear Displays
lc.clearDisplay(1);
lc.clearDisplay(2);
lc.clearDisplay(3);
Wire.begin();
mpu.initialize();
// Begin STOP STOP Hall Effect Setup
myDisplay.begin();
myDisplay.setIntensity(8);
myDisplay.displayClear();
pinMode(hallSensorPin, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(hallSensorPin), sensorInterrupt, FALLING); // Attach interrupt on CHANGE
// End STOP STOP Hall Effect Setup
}
void loop()
{
int16_t ax, ay, az;
mpu.getAcceleration(&ax, &ay, &az);
// Detect tilt direction
if (ax > 10000) // Tilt to the right
{
// Put #1 frame on both Displays
sinvader1a();
delay(delayTime);
sinvader2a();
delay(delayTime);
// Put #2 frame on both Displays
sinvader3a();
delay(delayTime);
sinvader4a();
delay(delayTime);
// Put #3 frame on both Displays
sinvader1b();
delay(delayTime);
sinvader2b();
delay(delayTime);
// Put #4 frame on both Displays
sinvader3b();
delay(delayTime);
sinvader4b();
delay(delayTime);
}
else if (ax < -10000) // Tilt to the left
{
// Put #1 frame on both Displays
sinvader4c();
delay(delayTime);
sinvader3c();
delay(delayTime);
// Put #2 frame on both Displays
sinvader2c();
delay(delayTime);
sinvader1c();
delay(delayTime);
// Put #3 frame on both Displays
sinvader4d();
delay(delayTime);
sinvader3d();
delay(delayTime);
// Put #4 frame on both Displays
sinvader2d();
delay(delayTime);
sinvader1d();
delay(delayTime);
}
// Begin STOP STOP Hall Effect Loop
if (sensorTriggered) {
myDisplay.displayScroll("STOP STOP STOP STOP ", PA_CENTER, PA_SCROLL_RIGHT, 30);
sensorTriggered = false;
}
if (myDisplay.displayAnimate()) {
myDisplay.displayClear();
}
// End STOP STOP Hall Effect Loop
}
// Take values in Arrays and Display them
void sinvader1a()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(0, i, invader1a[i]);
}
}
void sinvader1b()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(0, i, invader1b[i]);
}
}
void sinvader2a()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(1, i, invader2a[i]);
}
}
void sinvader2b()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(1, i, invader2b[i]);
}
}
void sinvader3a()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(2, i, invader3a[i]);
}
}
void sinvader3b()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(2, i, invader3b[i]);
}
}
void sinvader4a()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(3, i, invader4a[i]);
}
}
void sinvader4b()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(3, i, invader4b[i]);
}
}
void sinvader4c()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(3, i, invader4c[i]);
}
}
void sinvader3c()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(2, i, invader3c[i]);
}
}
void sinvader2c()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(1, i, invader2c[i]);
}
}
void sinvader1c()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(0, i, invader1c[i]);
}
}
void sinvader4d()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(3, i, invader4d[i]);
}
}
void sinvader3d()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(2, i, invader3d[i]);
}
}
void sinvader2d()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(1, i, invader2d[i]);
}
}
void sinvader1d()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(0, i, invader1d[i]);
}
}
It’s probably a. good time to add Serial.begin(xxxx) to setup.
with xxx matching your serial monitor or terminal,program.
I've tried it and it still work the same. The MPU6050 is not working and the STOP STOP that is displayed whenever the Hall Effect receives a high magnetic field is still too slow after integrating the Serial.begin(9600)
My code did not include activating the serial interface
You have to adjust the baudrate of the serial monitor to 115200
Here is a version that does activating the serial interface
#include "LedControl.h"
#include <Wire.h>
#include <MPU6050.h>
LedControl lc = LedControl(51, 52, 53, 4); // Pins: DIN, CLK, CS, # of Displays connected
MPU6050 mpu;
unsigned long delayTime = 200; // Delay between Frames
// Put values in arrays
byte invader1a[] =
{
B00010010, // First frame of invader #1
B00100100,
B01001001,
B10010010,
B10010010,
B01001001,
B00100100,
B00010010
};
byte invader1b[] =
{
B00000000, // Second frame of invader #1
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000
};
byte invader2a[] =
{
B00010010, // First frame of invader #1
B00100100,
B01001001,
B10010010,
B10010010,
B01001001,
B00100100,
B00010010
};
byte invader2b[] =
{
B00000000, // Second frame of invader #2 (flipped horizontally)
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000
};
byte invader3a[] =
{
B00010010, // First frame of invader #1
B00100100,
B01001001,
B10010010,
B10010010,
B01001001,
B00100100,
B00010010
};;
byte invader3b[] =
{
B00000000, // First frame of invader #2 (flipped horizontally)
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000
};
byte invader4a[] =
{
B00010010, // First frame of invader #1
B00100100,
B01001001,
B10010010,
B10010010,
B01001001,
B00100100,
B00010010
};
byte invader4b[] =
{
B00000000, // Second frame of invader #2
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000
};
// Put values in arrays
byte invader1c[] =
{
B01001000, // First frame of invader #1
B00100100,
B10010010,
B01001001,
B01001001,
B10010010,
B00100100,
B01001000
};
byte invader1d[] =
{
B00000000, // Second frame of invader #1
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000
};
byte invader2c[] =
{
B01001000, // First frame of invader #1
B00100100,
B10010010,
B01001001,
B01001001,
B10010010,
B00100100,
B01001000
};
byte invader2d[] =
{
B00000000, // Second frame of invader #2 (flipped horizontally)
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000
};
byte invader3c[] =
{
B01001000, // First frame of invader #1
B00100100,
B10010010,
B01001001,
B01001001,
B10010010,
B00100100,
B01001000
};
byte invader3d[] =
{
B00000000, // First frame of invader #2 (flipped horizontally)
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000
};
byte invader4c[] =
{
B01001000, // First frame of invader #1
B00100100,
B10010010,
B01001001,
B01001001,
B10010010,
B00100100,
B01001000
};
byte invader4d[] =
{
B00000000, // Second frame of invader #2
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000
};
void setup()
{
Serial.begin(115200);
Serial.println("Setup-Start");
lc.shutdown(0, false); // Wake up displays
lc.shutdown(1, false);
lc.shutdown(2, false);
lc.shutdown(3, false);
Serial.println("lc.shutdown done");
lc.setIntensity(0, 5); // Set intensity levels
lc.setIntensity(1, 5);
lc.setIntensity(2, 5);
lc.setIntensity(3, 5);
Serial.println("lc.setIntensity done");
lc.clearDisplay(0); // Clear Displays
lc.clearDisplay(1);
lc.clearDisplay(2);
lc.clearDisplay(3);
Serial.println("lc.clearDisplay done");
Wire.begin();
Serial.println("Wire.begin() done");
mpu.initialize();
Serial.println("mpu.initialize() done");
Serial.println("exiting setup");
}
void loop()
{
int16_t ax, ay, az;
mpu.getAcceleration(&ax, &ay, &az);
int rangeOfAX = 0; // initialise indicating variable with ZERO
// Detect tilt direction
if (ax > 10000) // Tilt to the right
{
rangeOfAX = 11000; // set indicating variable to a high positiv value
// Put #1 frame on both Displays
sinvader1a();
delay(delayTime);
sinvader2a();
delay(delayTime);
// Put #2 frame on both Displays
sinvader3a();
delay(delayTime);
sinvader4a();
delay(delayTime);
// Put #3 frame on both Displays
sinvader1b();
delay(delayTime);
sinvader2b();
delay(delayTime);
// Put #4 frame on both Displays
sinvader3b();
delay(delayTime);
sinvader4b();
delay(delayTime);
}
else if (ax < -10000) // Tilt to the left
{
rangeOfAX = -19000; // set indicating variable to a very negative value
// Put #1 frame on both Displays
sinvader4c();
delay(delayTime);
sinvader3c();
delay(delayTime);
// Put #2 frame on both Displays
sinvader2c();
delay(delayTime);
sinvader1c();
delay(delayTime);
// Put #3 frame on both Displays
sinvader4d();
delay(delayTime);
sinvader3d();
delay(delayTime);
// Put #4 frame on both Displays
sinvader2d();
delay(delayTime);
sinvader1d();
delay(delayTime);
}
// print in which range the indicating variable is
if (rangeOfAX == -19000) {
Serial.println("HIGH negative values of ax");
}
if (rangeOfAX == 11000) {
Serial.println("HIGH POSITIVE values of ax");
}
if (rangeOfAX == 0) {
Serial.println("range of ax between -10000 and + 10000");
}
}
// Take values in Arrays and Display them
void sinvader1a()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(0, i, invader1a[i]);
}
}
void sinvader1b()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(0, i, invader1b[i]);
}
}
void sinvader2a()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(1, i, invader2a[i]);
}
}
void sinvader2b()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(1, i, invader2b[i]);
}
}
void sinvader3a()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(2, i, invader3a[i]);
}
}
void sinvader3b()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(2, i, invader3b[i]);
}
}
void sinvader4a()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(3, i, invader4a[i]);
}
}
void sinvader4b()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(3, i, invader4b[i]);
}
}
void sinvader4c()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(3, i, invader4c[i]);
}
}
void sinvader3c()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(2, i, invader3c[i]);
}
}
void sinvader2c()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(1, i, invader2c[i]);
}
}
void sinvader1c()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(0, i, invader1c[i]);
}
}
void sinvader4d()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(3, i, invader4d[i]);
}
}
void sinvader3d()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(2, i, invader3d[i]);
}
}
void sinvader2d()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(1, i, invader2d[i]);
}
}
void sinvader1d()
{
for (int i = 0; i < 8; i++)
{
lc.setRow(0, i, invader1d[i]);
}
}
try again
I've tried it and it worked perfectly, thank you so much, the only left thing to do is integrate it with the Hall effect coding and it will be perfect, thank you very much again
No there is another thing for makingit "perfect".
DETAILED information.
What does the serial monitor show?
Post the printing as a code-secrtion
proceeding in SMALL steps
By writing a small testcode that does nothing more than printing the values of the hall-effect sensor
Again post the printing as a code-section