I am using Arduino Uno, trying to control LCD screen type UC1638 (240x128 monochrome) I want to fillup the screen in black). Searching up the internet I ended up using this code (written in C):
/* The below source code is from the LCD manufacturer, when he has no
idea about Arduino, this is translated from code he gave me for AVR
- I assume "sbit" is just Arduino GPIO settings, so I changed them
here accordingly - but I am not sure if it is the correct settings I
shall use for the LCD screen via Arduino
*/
#include "stdio.h"
#include "stdlib.h"
//sbit RST = P3^1;
//sbit CD = P3^0;
//sbit SCK = P1^0; //WRB=WR0
//sbit SDA = P1^1; //RDB=WR1
//sbit CS = P3^2;
void writei(unsigned char Cbyte)
{
unsigned char i;
digitalWrite(11, LOW); //CS=0;
digitalWrite(12, LOW); //CD=0;
for(i=0;i<8;i++) {
digitalWrite(SCK, LOW); // SCK=0;
digitalWrite(SDA, Cbyte&0x80?HIGH:LOW); // SDA=Cbyte&0x80?1:0;
digitalWrite(SCK, HIGH); // SCK=1;
Cbyte=Cbyte<<1;
}
digitalWrite(11, HIGH); // CS=1;
}
void writed(unsigned char Dbyte) {
unsigned char i;
digitalWrite(11, LOW); //CS=0;
digitalWrite(12, HIGH); //CD=1;
for(i=0;i<8;i++) {
digitalWrite(SCK, LOW); // SCK=0;
digitalWrite(SDA, Dbyte&0x80?HIGH:LOW); // SDA=Dbyte&0x80?1:0;
digitalWrite(SCK, HIGH); // SCK=1;
Dbyte=Dbyte<<1;
}
digitalWrite(11, HIGH); // CS=1;
}
void DelayMS(unsigned int MS)
{
unsigned char us,usn;
while(MS!=0)
{
usn=2;
while(usn!=0) { us=0xf6; while(us!=0){us--;}; usn--; }
MS--;
}
}
void LCD_INIT(void) {
//writei(0xe3);//system reset
digitalWrite(13, LOW); // RST=0;
DelayMS(10); //1ms
digitalWrite(13, HIGH); // RST=1;
DelayMS(500);//Delay more than 150ms.
writei(0xe1);//system reset
writed(0xe2);
DelayMS(2);
writei(0x04);//set column Address
writed(0x00);//
//writei(0x2f);// internal VLCD
//writei(0x26);// TC
writei(0xEb);//set bias=1/12
writei(0x81);//set vop
writed(90);// pm=106 Set VLCD=15V
writei(0xb8);//屏蔽MTP
writed(0x00);
writei(0xC4);//set lcd mapping control
//writei(0x00); //MY MX 0
writei(0xA3);//set line rate 20klps
writei(0x95); // PT0 1B P P
//writei(90);
writei(0xf1); //set com end
writed(159); //set com end 240*128
writei(0xC2);
writei(0x31); //APC
writed(0X91); // 1/0: sys_LRM_EN disable
writei(0xc9);
writed(0xad); // display
}
void setWindowsProgame() //com36--160 seg51--205
{
writei(0x04); //colum
writed(0x00);
writei(0x60); //page
writei(0x70);
writei(0xf4);
writed(0); //startx
writei(0xf6);
writed(239); //endx
writei(0xf5);
writed(0); //
writei(0xf7);
writed(15); //endy PANGE 16页
writei(0xf9); //窗口功能开
writei(0xC4);//set lcd mapping control
}
void display_black(void)
{
int i,j,k;
setWindowsProgame();
for(i=0;i<240;i++) {
for(j=0;j<18;j++) { writei(0x01); writed(0xff); }
}
}
void display_wirte ()
{
int i,j,k;
setWindowsProgame();
for(i=0;i<240;i++) {
for(j=0;j<18;j++) { writei(0x01); writed(0x00); }
}
}
void display_pic()
{
int i,j,K;
char d;
setWindowsProgame();
i=0;
K=0;
for(i=0;i<240*16;i++) //240*144
{
writei(0x01);
d=0xff; //d=PIC[K++];
writed(d);
}
}
void setup() {
// IO declaration: (GPIO setup)
pinMode(12, OUTPUT); // CD
pinMode(13, OUTPUT); // RST (RW)
pinMode(11, OUTPUT); // CS
pinMode(SCK, OUTPUT);
pinMode(SDA, OUTPUT);
LCD_INIT();
}
void loop(){
display_pic(); // Fill-up the screen in black
}
Notes:
The screen is 240*128 monochrome pixels.
Chip is UC1638
I am using Arduino Uno (if it helps regarding the available GPIOs)
I know about the "LiquidCrystal" library, but the examples gaven to me till now are for text screen of 16*2, not graphical screen - I believe that the GPIOs are completely different.
I want to "paint" the screen in black: Though the compilation passes OK, the LCD screen seems empty (transparent), but it has power - What I am doing wrong?
Thanks a lot
EDIT:
* I added SCK+SDA pins mark as output - Though I believe pins connected OK, the result is still the same. If the code is OK, then I will double check my pins...
I found and solved some problems in the code:
First, the delay of the delayms function in the source code is not accurate, so I replaced it with the delay function in Arduino.
Then, the value (90) of Vbias (command 0x81) set during LCD initialization is low. After changing to 200, the contrast is significantly improved.
Finally, this is the current code, which runs well on STM32F103C8T6:
#include <stdio.h>
#include <stdlib.h>
#define SDA PA7
#define SCK PA5
#define RST PB6
#define CS PB10
#define CD PB0
void writei(unsigned char Cbyte)
{
unsigned char i;
digitalWrite(CS, LOW); //CS=0;
digitalWrite(CD, LOW); //CD=0;
for(i=0;i<8;i++) {
digitalWrite(SCK, LOW); // SCK=0;
digitalWrite(SDA, Cbyte&0x80?HIGH:LOW); // SDA=Cbyte&0x80?1:0;
digitalWrite(SCK, HIGH); // SCK=1;
Cbyte=Cbyte<<1;
}
digitalWrite(CS, HIGH); // CS=1;
}
void writed(unsigned char Dbyte) {
unsigned char i;
digitalWrite(CS, LOW); //CS=0;
digitalWrite(CD, HIGH); //CD=1;
for(i=0;i<8;i++) {
digitalWrite(SCK, LOW); // SCK=0;
digitalWrite(SDA, Dbyte&0x80?HIGH:LOW); // SDA=Dbyte&0x80?1:0;
digitalWrite(SCK, HIGH); // SCK=1;
Dbyte=Dbyte<<1;
}
digitalWrite(CS, HIGH); // CS=1;
}
void LCD_INIT(void) {
//writei(0xe3);//system reset
digitalWrite(RST, LOW); // RST=0;
delay(10); //1ms
digitalWrite(RST, HIGH); // RST=1;
delay(500);//Delay more than 150ms.
writei(0xe1);//system reset
writed(0xe2);
delay(2);
writei(0x04);//set column Address
writed(0x00);
//writei(0x2f);// internal VLCD
//writei(0x26);// TC
writei(0xEb);//set bias=1/12
writei(0x81);//set vop
writed(200);// pm=106 Set VLCD=15V
writei(0xb8);//屏蔽MTP
writed(0x00);
writei(0xC4);//set lcd mapping control
//writei(0x00); //MY MX 0
writei(0xA3);//set line rate 20klps
writei(0x95); // PT0 1B P P
//writei(90);
writei(0xf1); //set com end
writed(159); //set com end 240*128
writei(0xC2);
writei(0x31); //APC
writed(0X91); // 1/0: sys_LRM_EN disable
writei(0xc9);
writed(0xad); // display
}
void setWindowsProgame() //com36--160 seg51--205
{
writei(0x04); //colum
writed(0x00);
writei(0x60); //page
writei(0x70);
writei(0xf4);
writed(0); //startx
writei(0xf6);
writed(239); //endx
writei(0xf5);
writed(0); //
writei(0xf7);
writed(19); //endy PANGE 16页
writei(0xf9); //窗口功能开
writei(0xC4);//set lcd mapping control
}
void display_black(void)
{
int i,j,k;
setWindowsProgame();
for(i=0;i<240;i++) {
for(j=0;j<20;j++) { writei(0x01); writed(0xff); }
}
}
void display_wirte()
{
int i,j,k;
setWindowsProgame();
for(i=0;i<240;i++) {
for(j=0;j<20;j++) { writei(0x01); writed(0x00); }
}
}
void display_pic()
{
int i,j,K;
char d;
setWindowsProgame();
i=0;
K=0;
for(i=0;i<240*20;i++) //240*144
{
writei(0x01);
d=0xff; //d=PIC[K++];
writed(d);
}
}
void setup() {
// IO declaration: (GPIO setup)
pinMode(CD, OUTPUT); // CD
pinMode(RST, OUTPUT); // RST (RW)
pinMode(CS, OUTPUT); // CS
pinMode(SCK, OUTPUT);
pinMode(SDA, OUTPUT);
LCD_INIT();
}
void loop(){
display_black(); // Fill-up the screen in black
delay(1000);
display_wirte();
delay(1000);
}
Related
I have this program that prins to an LCD with watchdog interrupt. But the problem is that i need to have 2 decimals after seconds.
the code is as follows:
#include <Arduino.h>
#include "DFRobot_RGBLCD.h"
#include <stm32l4xx_hal_iwdg.h>
#include <Wire.h>
#define I2C2_SCL PB10
#define I2C2_SDA PB11
DFRobot_RGBLCD lcd(16,2);
TwoWire dev_i2c (I2C2_SDA, I2C2_SCL);
IWDG_HandleTypeDef watchdog;
void Start();
void Pause();
int paused = 0;
int milli = 0;
volatile byte state = HIGH;
void setup() {
pinMode(A2, INPUT_PULLUP);
pinMode(A3, INPUT_PULLUP);
lcd.init();
Serial.begin(9600);
dev_i2c.begin();
attachInterrupt(A2, Start, FALLING);
attachInterrupt(A3, Pause,RISING);
watchdog.Instance = IWDG;
watchdog.Init.Prescaler = IWDG_PRESCALER_256;
watchdog.Init.Reload = 1220;
watchdog.Init.Window = 0x0FFF;
HAL_IWDG_Init(&watchdog);
delay(1);
}
void loop() {
if(state){
delay(250);
lcd.setCursor(0, 0);
lcd.print("Sekunder: ");
lcd.print(millis()/1000-pause);
delay(100);
}
else{
delay(1000);
paused++;
HAL_IWDG_Refresh(&watchdog);
}
}
void Start(){
state = HIGH;
HAL_IWDG_Refresh(&watchdog);
delay(10);
}
void Pause(){
state = !state;
delay(10);
}
I have tried to put the -pause outside the lcd.print, but that didnt work. i've also tried this codeline: ```
lcd.print(millis()/1000.0, 2-paused);
But it seems like it takes -paused from the number 2. Do anyone have suggestion to how i can make it work so i get the 2 decimals?
String seconds = String(millis() / 1000.0, 2);
lcd.print(seconds);
Currently, I am making a project for my school and I am having an issue when the code runs multiple times. I am using an Arduino Mega 2560. The project I am doing is making a safe/box that requires a PIN to open it. In order of how things are supposed to operate it follows:
The IR receiver receives a signal from a remote that activates the signal. When the system is active it turns on a blue LED. When the system is inactive it does nothing.
When the system is active, it can read inputs from the 4x4 pin pad. If it gets a wrong code it turns on a red LED then clears the data so it can take in the code again. If the correct code is given then a green LED is turned on and turns a servo motor 90 degrees.
After the correct code is turned on, a button is pressed to return the motor to 0 degrees and deactivates the system.
The issue is that after the button is pressed I cannot reactivate the system. It basically becomes a 1 and done. The code for the project can be found below.
#include <Keypad.h>
#include <Servo.h>
#include <IRremote.h>
Servo servo;
const byte ROWS = 4;
const byte COLS = 4;
#define Passcode_L 5
char Data[Passcode_L];
char Master[Passcode_L]="14B6";
char hexaKeys[ROWS][COLS] = {
{'1', '2', '3', 'A'},
{'4', '5', '6', 'B'},
{'7', '8', '9', 'C'},
{'*', '0', '#', 'D'}
};
byte rowPins[ROWS] = {22, 24, 26, 28};
byte colPins[COLS] = {30, 32, 34, 36};
byte data_count = 0;
char customKey;
Keypad customKeypad = Keypad(makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS);
const int led_blue = 23;
const int led_green = 25;
const int led_red = 27;
const int BUTTON = 47;
int BUTTONstate = 0;
const int RECV_PIN = 44;
int togglestate = 0;
IRrecv irrecv(RECV_PIN);
decode_results results;
void setup(){
Serial.begin(9600);
irrecv.enableIRIn();
servo.attach(38);
servo.write(0);
pinMode(led_blue, OUTPUT);
pinMode(led_green, OUTPUT);
pinMode(led_red, OUTPUT);
pinMode(BUTTON, INPUT);
}
void loop(){
char customKey = customKeypad.getKey();
BUTTONstate = digitalRead(BUTTON);
if (irrecv.decode(&results)){
switch(results.value){
case 0xFFA25D:
// Toggle BLUE LED On or Off
if(togglestate==0){
digitalWrite(led_blue, HIGH);
togglestate=1;
}
else {
digitalWrite(led_blue, LOW);
togglestate=0;
}
break;
}
irrecv.resume();
}
if (customKey){
Data[data_count] = customKey;
data_count++;
}
if (data_count == Passcode_L - 1 && togglestate==1) {
if (!strcmp(Data, Master)) {
//password is correct
digitalWrite(led_green, HIGH);
delay(500);
servo.write(90);
delay(1500);
digitalWrite(led_green, LOW);
}
else {
// Password is incorrect
digitalWrite(led_red, HIGH);
delay(1000);
digitalWrite(led_red, LOW);
}
clearData();
}
if (BUTTONstate !=0){
servo.write(0);
togglestate=0;
digitalWrite(led_blue, LOW);
}
}
void clearData() {
// Go through array and clear data
while (data_count != 0) {
Data[data_count--] = 0;
}
return;
}
The logic in your program is fairly hard to follow, and change without breaing everything... I think the problem is a design issue. Your code is written to react to events, but does not properly track in which state you device is. And state is. Keeping track of state is very important. It's probably the most important thing to do when programming embedded devices. And for a lock, I really think it definitely is the most important thing to keep track of.
Try this: you have a lock, it has these distinct states:
locked (stable state)
entering passcode (transitional -> error or unlocking) (needs aborted entry timeout?)
show passcode error (transitional -> locked)
unlocking (transitional -> unlocked)
unlocked (stable)
locking (transitional -> locked)
If you keep track of the state of your device, and separating the logic for each state, the logic will become much easier to manage and debug. It also makes adding features and extra logic almost trivial. I thin you should try something like this:
#include <Keypad.h>
#include <Servo.h>
#include <IRremote.h>
const byte ROWS = 4;
const byte COLS = 4;
// IO pins
byte rowPins[ROWS] = {22, 24, 26, 28};
byte colPins[COLS] = {30, 32, 34, 36};
const int led_blue = 23;
const int led_green = 25;
const int led_red = 27;
const int BUTTON = 47;
const int RECV_PIN = 44;
// devices
Servo servo;
IRrecv irrecv(RECV_PIN);
char hexaKeys[ROWS][COLS] = {
{'1', '2', '3', 'A'},
{'4', '5', '6', 'B'},
{'7', '8', '9', 'C'},
{'*', '0', '#', 'D'}
};
Keypad customKeypad = Keypad(makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS);
// lock states
class enum LockState
{
locked,
passcodeEntry,
passcodeError,
unlocking,
unlocked,
locking,
};
// lock data
LockState lockState = locked;
byte data_count = 0;
bool passcodeOK = false;
unsigned int timeoutTS;
const char Master[] = "14B6";
#define Passcode_L (sizeof(Master) - 1)
#define TIMEOUT (30000) // 30 seconds timeout for data entry
void setup()
{
Serial.begin(9600);
irrecv.enableIRIn();
servo.attach(38);
servo.write(0);
pinMode(led_blue, OUTPUT);
pinMode(led_green, OUTPUT);
pinMode(led_red, OUTPUT);
pinMode(BUTTON, INPUT);
}
void loop()
{
switch (lockState)
{
default:
case LockState::locked:
{
// locked, resting. turn LEDs off, and clear received key code.
digitalWrite(led_blue, LOW);
digitalWrite(led_red, LOW);
digitalWrite(led_green, LOW);
data_count = 0;
decode_results results;
if (irrecv.decode(&results) && results.value == 0xFFA25D)
{
timeoutTS = (unsigned int)millis();
lockState = LockState::passcodeEntry;
}
}
break;
case LockState::passcodeEntry:
{
// read keypad, blue LED is on.
digitalWrite(led_blue, HIGH);
// this assumes customKeypad debounces the key and returns a non-zero
// value only once for each key, when it is initially pressed.
char customKey = customKeypad.getKey();
if (customKey)
{
timeoutTS = (unsigned int)millis();
if (data_count == 0)
passcodeOK = true;
// check passcode.
passcodeOK &= (customKey == Master[data_count++]);
if (data_count >= Passcode_L)
{
if (passcodeOK)
lockState = LockState::unlocking;
else
lockState = LockState::passcodeError;
}
// check for timeout, we wouldn't want to let anyone enter codes
// if the owner leaves the room now with the IR remote in his pocket
if ((unsigned int)millis() - timeoutTS > TIMEOUT)
lockState = LockState::locked;
}
break;
case LockState::passcodeError:
{
// turn on red LED for 1 second. then let use retry a passcode.
digitalWrite(led_red, HIGH);
delay(1000);
digitalWrite(led_red, LOW);
data_count = 0;
lockState = LockState::passcodeEntry;
}
break;
case LockState::unlocking:
{
digitalWrite(led_green, HIGH);
servo.write(90);
delay(1500);
digitalWrite(led_green, LOW);
lockState = LockState::unlocked;
}
break;
case LockState::unlocked:
{
// wait for button press.
if (digitalRead(BUTTON))
lockState = LockState::locking;
}
break;
case LockState::locking:
{
// turn the lock back, go back to locked state
servo.write(0);
loackState = LockState::locked;
}
break;
}
}
I don't have an arduino with me, and am not setup at the moment to compile a sketch, so there may be a couple compile errors, but the logic should be very close to what you want to achieve.
I am using Arduino Uno, I try to run servo constantly from 0 to 45 degrees when the interrupt button is pressed it should go to -30 degree and wait here. When the same button is pressed again, it should resume the constant action, which is swiping 0 to 45 degrees without <servo.h> library.
I tried to run like this:
const int servo = 11;
const int led = 13;
const int buttonPin = 2;
volatile int buttonState = 1;
void setup() {
Serial.begin(57600);
pinMode(led, OUTPUT);
pinMode(servo, OUTPUT);
pinMode(buttonPin, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(buttonPin),Button,CHANGE);
}
void loop() {
digitalWrite(led,HIGH);
for(int i=0;i<30;i++)
{
digitalWrite(servo,HIGH);
delayMicroseconds(1500);
digitalWrite(servo,LOW);
delayMicroseconds(18500);
}
delay(2000);
for(int i=0;i<30;i++)
{
digitalWrite(servo,HIGH);
delayMicroseconds(1000);
digitalWrite(servo,LOW);
delayMicroseconds(19000);
}
delay(2000);
}
void Button()
{
digitalWrite(led,LOW);
for(int i=0;i<30;i++)
{
digitalWrite(servo,HIGH);
delayMicroseconds(1833);
digitalWrite(servo,LOW);
delayMicroseconds(18167);
}
}
I have no problem coding my own PWM for each case but it turns out, the problem is a bit complicated than I was expecting because when we try to resume, I need to disable the interrupt function when pressing the same an interrupt button somehow.
Is it possible in this way or is there a better way to implement it?
So I have an Arduino sketch that reads serial commands (a string of chars) and then have the sketch do something based on the command it receives. As of right now I have two commands,
{open_valve}
{close_valve}
When I send the command, {open_valve} to the Arduino, the valve opens fine, but the valve is not closing when I send the command {close_valve} to the Arduino. The sketch looks like the following,
// flow_A LED
int led = 4;
// relay_A
const int RELAY_A = A0;
// variables from sketch example
String inputString = ""; // a string to hold incoming data
boolean stringComplete = false; // whether the string is complete
// variables from SO thread
boolean LED_state = false;
boolean vavle_open = false;
// flowmeter shit
unsigned long totalCount = 0;
unsigned long previousCount = 0;
int pin = 2;
unsigned long duration;
// storage variable for the timer
unsigned long previousMillis=0;
int interval=1000; //in milliseconds
// counters for each flowmeter
unsigned long countA = 0;
void setup() {
Serial.begin(115200); // open serial port, sets data rate to 115200bps
Serial.println("Power on test");
inputString.reserve(200);
pinMode(RELAY_A, OUTPUT);
// flowmeter shit
pinMode(pin, INPUT);
}
void open_valve() {
digitalWrite(RELAY_A, HIGH); // turn RELAY_A on
// set the boolean value for "vavle_open" to true
//valve_open = true;
Serial.println("Valve Open");
}
void close_valve() {
Serial.println("2");
digitalWrite(RELAY_A, LOW); // turn RELAY_A off
//valve_open = false;
Serial.println("3");
Serial.println("Vavle Closed");
}
void controlValve(bool open)
{
}
void flow_A_blink() {
digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for one second
digitalWrite(led, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}
void flow_A_blink_stop() {
digitalWrite(led, LOW);
}
void getFlow() {
duration = pulseIn(pin, HIGH);
Serial.print(duration);
Serial.println("");
delay(200);
}
/*
* Main program loop, runs over and over repeatedly
*/
void loop() {
if(checkForCorrectCommand("{open_valve}") == true) {
open_valve();
Serial.println("OPENING");
getFlow();
}
else if(checkForCorrectCommand("{close_valve}") == true)
{
close_valve();
Serial.println("CLOSING");
}
}
bool checkForCorrectCommand(String cmd) {
//Serial.println(inputString);
//Serial.println(cmd);
if(inputString == cmd) {
// reset String variables for serial data commands
Serial.println("1");
inputString = "";
stringComplete = false;
return true;
// reset String variables for serial data commands
inputString = "";
stringComplete = false;
return false;
}
}
//SerialEvent occurs whenever a new data comes in the
//hardware serial RX. This routine is run between each
//time loop() runs, so using delay inside loop can delay
//response. Multiple bytes of data may be available.
void serialEvent() {
while(Serial.available()) {
// get the new byte:
char inChar = (char)Serial.read();
// add it to the inputString:
inputString += inChar;
// if the incoming character is a newline, set a flag
// so the main loop can do something about it:
if (inChar == '\n') {
stringComplete = true;
}
}
}
Your code should not compile as pasted here. The checkForCorrectCommand function does not have a return value for both the match and unmatch. Your code shows you intend to empty the inputString buffer for both the match and non matched case. If the string match is not true, you want to leave the input buffer unchanged so that the following test cases can run.
bool checkForCorrectCommand(String cmd) {
if(inputString == cmd) {
// for match case, the string is consumed from the buffer
inputString = "";
stringComplete = false;
return true;
}
else {
// for the non-match case, leave the buffer for further Rx or further tests
return false;
}
So I modified my sketch with the following code, and now it seems to processing the serial commands the way I want it too.
// flow_A LED
int led = 4;
// relay_A
const int RELAY_A = A0;
// variables from sketch example
String inputString = ""; // a string to hold incoming data
boolean stringComplete = false; // whether the string is complete
// variables from SO thread
boolean LED_state = false;
boolean vavle_open = false;
// flowmeter shit
unsigned long totalCount = 0;
unsigned long previousCount = 0;
int pin = 2;
unsigned long duration;
// storage variable for the timer
unsigned long previousMillis=0;
int interval=1000; //in milliseconds
// counters for each flowmeter
unsigned long countA = 0;
void setup() {
// initialize serial
Serial.begin(9600); // open serial port, sets data rate to 115200bps
// Serial.println("Power on test - println");
// line below is for iPhone testing
// Serial.write("Power on test - write");
inputString.reserve(200);
pinMode(RELAY_A, OUTPUT);
// flowmeter shit
pinMode(pin, INPUT);
}
void open_valve() {
digitalWrite(RELAY_A, HIGH); // turn RELAY_A on
// Serial.println("Valve Open");
Serial.write("{valve_open}");
}
void close_valve() {
digitalWrite(RELAY_A, LOW); // turn RELAY_A off
// Serial.println("Vavle Closed");
Serial.write("{valve_close}");
}
void flow_A_blink() {
digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for one second
digitalWrite(led, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}
void flow_A_blink_stop() {
digitalWrite(led, LOW);
}
void getFlow() {
duration = pulseIn(pin, HIGH);
Serial.print(duration);
Serial.println("");
delay(200);
}
/*
* Main program loop, runs over and over repeatedly
*/
void loop() {
//print the string when a newline arrives:
if(stringComplete) {
// Serial.println(inputString);
if(inputString.equals("{open_valve}\n")) {
// Serial.println("opening valve.");
open_valve();
}
if(inputString.equals("{open_valve}")) {
// Serial.println("opening valve.");
open_valve();
}
if(inputString.equals("{close_valve}\n")) {
// Serial.println("close vavle.");
close_valve();
}
if(inputString.equals("{close_valve}")) {
// Serial.println("close vavle.");
close_valve();
}
// clear the string:
inputString = "";
stringComplete = false;
}
}
/*
SerialEvent occurs whenever a new data comes in the
hardware serial RX. This routine is run between each
time loop() runs, so using delay inside loop can delay
response. Multiple bytes of data may be available.
*/
void serialEvent() {
while(Serial.available()) {
// get the new byte:
char inChar = (char)Serial.read();
// add it to the inputString:
inputString += inChar;
// if the incoming character is a newline, set a flag
// so the main loop can do something about it:
if (inChar == '\n') {
stringComplete = true;
}
// Serial.println(inputString.length());
}
}
The note from jdr5ca is quite correct. The checkForCorrectCommand routine needed an else clause with a separate return statement. The solution devised by Chris is good. It is clearly better to only process the contents of inputString if it is complete and discard it (the contents of inputString) after checking for the valid commands. I would like to offer a minor change to serialEvent.
The serialEvent routine should not keep adding characters to a string that is already complete. Instead it should leave them in the buffer to help form the next command. See the code below.
void serialEvent() {
if (stringComplete)
return;
while(Serial.available()) {
// get the new byte:
char inChar = (char)Serial.read();
// add it to the inputString:
inputString += inChar;
// if the incoming character is a newline, set a flag
// so the main loop can do something about it:
if (inChar == '\n') {
stringComplete = true;
}
}
}
Alright I have a half complete Arduino sketch at the moment. Basically the sketch below will blink an LED on a kegboard-mini shield if a string of chars equals *{blink_Flow_A}* However the LED only blinks once with the current sketch loaded on the Arduino. I will like the Arduino to blink repeatedly until the "stop" command is sent to the Arduino. I would eventually like to open a valve, keep it open until the valve receives to the close command then close the valve. The sketch looks like the following,
/*
* kegboard-serial-simple-blink07
* This code is public domain
*
* This sketch sends a receives a multibyte String from the iPhone
* and performs functions on it.
*
* Examples:
* http://arduino.cc/en/Tutorial/SerialEvent
* http://arduino.cc/en/Serial/read
*/
// global variables should be identified with _
// flow_A LED
int led = 4;
// relay_A
const int RELAY_A = A0;
// variables from sketch example
String inputString = ""; // a string to hold incoming data
boolean stringComplete = false; // whether the string is complete
void setup() {
Serial.begin(2400); // open serial port, sets data rate to 2400bps
Serial.println("Power on test");
inputString.reserve(200);
pinMode(RELAY_A, OUTPUT);
}
void open_valve() {
digitalWrite(RELAY_A, HIGH); // turn RELAY_A on
}
void close_valve() {
digitalWrite(RELAY_A, LOW); // turn RELAY_A off
}
void flow_A_blink() {
digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for one second
digitalWrite(led, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}
void flow_A_blink_stop() {
digitalWrite(led, LOW);
}
void loop() {
// print the string when newline arrives:
if (stringComplete) {
Serial.println(inputString);
// clear the string:
inputString = "";
stringComplete = false;
}
if (inputString == "{blink_Flow_A}") {
flow_A_blink();
}
}
//SerialEvent occurs whenever a new data comes in the
//hardware serial RX. This routine is run between each
//time loop() runs, so using delay inside loop can delay
//response. Multiple bytes of data may be available.
void serialEvent() {
while(Serial.available()) {
// get the new byte:
char inChar = (char)Serial.read();
// add it to the inputString:
inputString += inChar;
// if the incoming character is a newline, set a flag
// so the main loop can do something about it:
if (inChar == '\n') {
stringComplete = true;
}
}
}
If it makes any difference someone on IRC told me to research state machines scratches head
To blink a Led without blocking the program, i suggest you use Timer (and the TimerOne library). I make a quick sample code :
#include "TimerOne.h" //Include the librart, follow the previous link to download and install.
int LED = 4;
const int RELAY_A = A0;
boolean ledOn;
void setup()
{
pinMode(LED, OUTPUT)
Timer1.initialise(500000) // Initialise timer1 with a 1/2 second (500000µs) period
ledOn = false;
}
void blinkCallback() // Callback function call every 1/2 second when attached to the timer
{
if(ledOn){
digitalWrite(LED,LOW);
ledOn = false;
}
else{
digitalWrite(LED,HIGH);
ledOn = true;
}
}
void open_valve() {
digitalWrite(RELAY_A, HIGH); // turn RELAY_A on
}
void close_valve() {
digitalWrite(RELAY_A, LOW); // turn RELAY_A off
}
void serialEvent() {
while(Serial.available()) {
char inChar = (char)Serial.read();
inputString += inChar;
if (inChar == '\n') {
stringComplete = true;
}
}
}
void loop()
{
// print the string when newline arrives:
if (stringComplete) {
Serial.println(inputString);
// clear the string:
inputString = "";
stringComplete = false;
}
if (inputString == "{blink_Flow_A}") {
Timer1.attachInterupt(blinkCallback); //Start blinking
}
if (inputString == "{stop}") {
Timer1.detachInterrupt(); //Stop blinking
}
if (inputString == "{open_valve}") {
open_valve();
}
if (inputString == "{close_valve}") {
close_valve();
}
}
Note :
Consider putting the tag 'c' or 'java' to have syntax highlighting on the code.
A state machine (at it's simplest - it can be lots more complicated) can be just a set of conditional statements (if/else or switch/case) where you do certain behaviors based on the state of a variable, and also change that variable state. So it can be thought of as a way of handling or progressing through a series of conditions.
So you have the state of your LED/valve - it is either blinking (open) or not blinking (closed). In pseudo code here:
boolean LED_state = false; //init to false/closed
void loop(){
if (checkForCorrectCommand() == true){ //
if (LED_State == false){
open_valve();
LED_State = true;
} else {
close_valve();
LED_State = false;
}
}
}
The blinking LED part should be easy to implement if you get the gist of the code above. The checkForCorrectCommand() bit is a function you write for checking whatever your input is - key, serial, button, etc. It should return a boolean.
Perhaps something like the 'blink without delay' example in the IDE. You check the time and decide to when and how to change the LED/Digital out.
// Variables will change:
int ledState = LOW; // ledState used to set the LED
long previousMillis = 0; // will store last time LED was updated
// the follow variables is a long because the time, measured in miliseconds,
// will quickly become a bigger number than can be stored in an int.
long interval = 1000; // interval at which to blink (milliseconds)
void setup(){
// Your stuff here
}
void loop()
{
// Your stuff here.
// check to see if it's time to blink the LED; that is, if the
// difference between the current time and last time you blinked
// the LED is bigger than the interval at which you want to
// blink the LED.
unsigned long currentMillis = millis();
if(currentMillis - previousMillis > interval) {
// save the last time you blinked the LED
previousMillis = currentMillis;
// if the LED is off turn it on and vice-versa:
if (ledState == LOW)
ledState = HIGH;
else
ledState = LOW;
// set the LED with the ledState of the variable:
digitalWrite(ledPin, ledState);
}
}
Let me offer a suggested sketch with a few changes. Bastyen's idea of using a timer is quite good and makes the code much easier. The approach I would suggest is to have the timer pop forever at a fixed interval (100 milliseconds in my sketch). If the LED should not be blinking it stays off. If the LED should be blinking, it switches from off to on or vice versa each time the timer goes off.
#include "TimerOne.h"
/*
* kegboard-serial-simple-blink07
* This code is public domain
*
* This sketch sends a receives a multibyte String from the iPhone
* and performs functions on it.
*
* Examples:
* http://arduino.cc/en/Tutorial/SerialEvent
* http://arduino.cc/en/Serial/read
*/
// global variables should be identified with _
// flow_A LED
int led = 4;
// relay_A
const int RELAY_A = A0;
// variables from sketch example
String inputString = ""; // a string to hold incoming data
boolean stringComplete = false; // whether the string is complete
boolean shouldBeBlinking = false;
boolean ledOn = false;
void setup() {
Serial.begin(9600); // open serial port, sets data rate to 2400bps
Serial.println("Power on test");
inputString.reserve(200);
pinMode(RELAY_A, OUTPUT);
pinMode(led, OUTPUT);
digitalWrite(led, LOW);
Timer1.initialize(100000);
Timer1.attachInterrupt(timer1Callback);
}
void loop() {
if (!stringComplete)
return;
if (inputString == "{blink_Flow_A}")
flow_A_blink_start();
if (inputString == "{blink_Flow_B}")
flow_A_blink_stop();
inputString = "";
stringComplete = false;
}
void timer1Callback() {
/* If we are not in blinking mode, just make sure the LED is off */
if (!shouldBeBlinking) {
digitalWrite(led, LOW);
ledOn = false;
return;
}
/* Since we are in blinking mode, check the state of the LED. Turn
it off if it is on and vice versa. */
ledOn = (ledOn) ? false : true;
digitalWrite(led, ledOn);
}
void flow_A_blink_start() {
shouldBeBlinking = true;
open_valve();
}
void flow_A_blink_stop() {
shouldBeBlinking = false;
close_valve();
}
void close_valve() {
digitalWrite(RELAY_A, LOW); // turn RELAY_A off
}
void open_valve() {
digitalWrite(RELAY_A, HIGH); // turn RELAY_A on
}
//SerialEvent occurs whenever a new data comes in the
//hardware serial RX. This routine is run between each
//time loop() runs, so using delay inside loop can delay
//response. Multiple bytes of data may be available.
void serialEvent() {
if (stringComplete)
return;
while(Serial.available()) {
// get the new byte:
char inChar = (char)Serial.read();
// add it to the inputString unless it is a newline
if (inChar != '\n')
inputString += inChar;
// if the incoming character is a newline, set a flag
// so the main loop can do something about it:
else {
stringComplete = true;
}
}
}
A few notes:
The setup function establishes the timer with a 100 millisecond interval and attaches the callback routine. Based on my testing, this only needs to be done once.
The main loop just ignores everything unless an input string is complete. If an input string is ready, then the input string is checked for two known values and the appropriate steps are taken. The input string is then discarded.
The timer callback routine forces the LED off, if we are not in blinking mode. Otherwise, it just toggles the state of the LED.
The flow on and flow off routines set the blinking state as need be and control the valve
The serial event routine has two changes. First, input is ignored (and kept in the buffer) if an input string is already complete. This will preserve commands that are being sent to the Arduino while the current command is being processed. Second, the newline character is not added to the input string. This makes checking the input string slightly easier.