sbrl/arduino
sbrl/arduino
1
0
Fork 0
Code Issues Pull requests Activity

Compare commits

base: sbrl:a0b68ebc159f888a58f9ab2925c7e873e199e5e8
Branches Tags
sbrl:master
..
compare: sbrl:a5bd772ac58e15d4644b4c759f973c94ca6f354f
Branches Tags
sbrl:master

No commits in common. "a0b68ebc159f888a58f9ab2925c7e873e199e5e8" and "a5bd772ac58e15d4644b4c759f973c94ca6f354f" have entirely different histories.
a0b68ebc15 ... a5bd772ac5

14 changed files with 4 additions and 910 deletions
Show stats Expand all files Collapse all files

1
Examples/LCDTest/HC_LiquidCrystal_I2C.cpp
View file

@ -1 +0,0 @@
HC_LiquidCrystal_I2C/HC_LiquidCrystal_I2C.cpp

1
Examples/LCDTest/HC_LiquidCrystal_I2C.h
View file

@ -1 +0,0 @@
HC_LiquidCrystal_I2C/HC_LiquidCrystal_I2C.h

253
Examples/LCDTest/HC_LiquidCrystal_I2C/HC_LiquidCrystal_I2C.cpp
View file

@ -1,253 +0,0 @@
#include "HC_LiquidCrystal_I2C.h"
#include <inttypes.h>
#include <Arduino.h>
#include <Wire.h>
// When the display powers up, it is configured as follows:
//
// 1. Display clear
// 2. Function set:
// DL = 1; 8-bit interface data
// N = 0; 1-line display
// F = 0; 5x8 dot character font
// 3. Display on/off control:
// D = 0; Display off
// C = 0; Cursor off
// B = 0; Blinking off
// 4. Entry mode set:
// I/D = 1; Increment by 1
// S = 0; No shift
//
// Note, however, that resetting the Arduino doesn't reset the LCD, so we
// can't assume that its in that state when a sketch starts (and the
// LiquidCrystal constructor is called).
HC_LiquidCrystal_I2C::HC_LiquidCrystal_I2C(uint8_t lcd_addr, uint8_t lcd_cols, uint8_t lcd_rows, uint8_t charsize)
{
_addr = lcd_addr;
_cols = lcd_cols;
_rows = lcd_rows;
_charsize = charsize;
_backlightval = LCD_BACKLIGHT;
}
void HC_LiquidCrystal_I2C::begin() {
Wire.begin();
_displayfunction = LCD_4BITMODE | LCD_1LINE | LCD_5x8DOTS;
if (_rows > 1) {
_displayfunction |= LCD_2LINE;
}
// for some 1 line displays you can select a 10 pixel high font
if ((_charsize != 0) && (_rows == 1)) {
_displayfunction |= LCD_5x10DOTS;
}
// SEE PAGE 45/46 FOR INITIALIZATION SPECIFICATION!
// according to datasheet, we need at least 40ms after power rises above 2.7V
// before sending commands. Arduino can turn on way befer 4.5V so we'll wait 50
delay(50);
// Now we pull both RS and R/W low to begin commands
expanderWrite(_backlightval); // reset expanderand turn backlight off (Bit 8 =1)
delay(1000);
//put the LCD into 4 bit mode
// this is according to the hitachi HD44780 datasheet
// figure 24, pg 46
// we start in 8bit mode, try to set 4 bit mode
write4bits(0x03 << 4);
delayMicroseconds(4500); // wait min 4.1ms
// second try
write4bits(0x03 << 4);
delayMicroseconds(4500); // wait min 4.1ms
// third go!
write4bits(0x03 << 4);
delayMicroseconds(150);
// finally, set to 4-bit interface
write4bits(0x02 << 4);
// set # lines, font size, etc.
command(LCD_FUNCTIONSET | _displayfunction);
// turn the display on with no cursor or blinking default
_displaycontrol = LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF;
display();
// clear it off
clear();
// Initialize to default text direction (for roman languages)
_displaymode = LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT;
// set the entry mode
command(LCD_ENTRYMODESET | _displaymode);
home();
}
/********** high level commands, for the user! */
void HC_LiquidCrystal_I2C::clear(){
command(LCD_CLEARDISPLAY);// clear display, set cursor position to zero
delayMicroseconds(2000); // this command takes a long time!
}
void HC_LiquidCrystal_I2C::home(){
command(LCD_RETURNHOME); // set cursor position to zero
delayMicroseconds(2000); // this command takes a long time!
}
void HC_LiquidCrystal_I2C::setCursor(uint8_t col, uint8_t row){
int row_offsets[] = { 0x00, 0x40, 0x14, 0x54 };
if (row > _rows) {
row = _rows-1; // we count rows starting w/0
}
command(LCD_SETDDRAMADDR | (col + row_offsets[row]));
}
// Turn the display on/off (quickly)
void HC_LiquidCrystal_I2C::noDisplay() {
_displaycontrol &= ~LCD_DISPLAYON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void HC_LiquidCrystal_I2C::display() {
_displaycontrol |= LCD_DISPLAYON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
// Turns the underline cursor on/off
void HC_LiquidCrystal_I2C::noCursor() {
_displaycontrol &= ~LCD_CURSORON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void HC_LiquidCrystal_I2C::cursor() {
_displaycontrol |= LCD_CURSORON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
// Turn on and off the blinking cursor
void HC_LiquidCrystal_I2C::noBlink() {
_displaycontrol &= ~LCD_BLINKON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void HC_LiquidCrystal_I2C::blink() {
_displaycontrol |= LCD_BLINKON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
// These commands scroll the display without changing the RAM
void HC_LiquidCrystal_I2C::scrollDisplayLeft(void) {
command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVELEFT);
}
void HC_LiquidCrystal_I2C::scrollDisplayRight(void) {
command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVERIGHT);
}
// This is for text that flows Left to Right
void HC_LiquidCrystal_I2C::leftToRight(void) {
_displaymode |= LCD_ENTRYLEFT;
command(LCD_ENTRYMODESET | _displaymode);
}
// This is for text that flows Right to Left
void HC_LiquidCrystal_I2C::rightToLeft(void) {
_displaymode &= ~LCD_ENTRYLEFT;
command(LCD_ENTRYMODESET | _displaymode);
}
// This will 'right justify' text from the cursor
void HC_LiquidCrystal_I2C::autoscroll(void) {
_displaymode |= LCD_ENTRYSHIFTINCREMENT;
command(LCD_ENTRYMODESET | _displaymode);
}
// This will 'left justify' text from the cursor
void HC_LiquidCrystal_I2C::noAutoscroll(void) {
_displaymode &= ~LCD_ENTRYSHIFTINCREMENT;
command(LCD_ENTRYMODESET | _displaymode);
}
// Allows us to fill the first 8 CGRAM locations
// with custom characters
void HC_LiquidCrystal_I2C::createChar(uint8_t location, uint8_t charmap[]) {
location &= 0x7; // we only have 8 locations 0-7
command(LCD_SETCGRAMADDR | (location << 3));
for (int i=0; i<8; i++) {
write(charmap[i]);
}
}
// Turn the (optional) backlight off/on
void HC_LiquidCrystal_I2C::noBacklight(void) {
_backlightval=LCD_NOBACKLIGHT;
expanderWrite(0);
}
void HC_LiquidCrystal_I2C::backlight(void) {
_backlightval=LCD_BACKLIGHT;
expanderWrite(0);
}
/*********** mid level commands, for sending data/cmds */
inline void HC_LiquidCrystal_I2C::command(uint8_t value) {
send(value, 0);
}
inline size_t HC_LiquidCrystal_I2C::write(uint8_t value) {
send(value, Rs);
return 1;
}
/************ low level data pushing commands **********/
// write either command or data
void HC_LiquidCrystal_I2C::send(uint8_t value, uint8_t mode) {
uint8_t highnib=value&0xf0;
uint8_t lownib=(value<<4)&0xf0;
write4bits((highnib)|mode);
write4bits((lownib)|mode);
}
void HC_LiquidCrystal_I2C::write4bits(uint8_t value) {
expanderWrite(value);
pulseEnable(value);
}
void HC_LiquidCrystal_I2C::expanderWrite(uint8_t _data){
Wire.beginTransmission(_addr);
Wire.write((int)(_data) | _backlightval);
Wire.endTransmission();
}
void HC_LiquidCrystal_I2C::pulseEnable(uint8_t _data){
expanderWrite(_data | En); // En high
delayMicroseconds(1); // enable pulse must be >450ns
expanderWrite(_data & ~En); // En low
delayMicroseconds(50); // commands need > 37us to settle
}
void HC_LiquidCrystal_I2C::load_custom_character(uint8_t char_num, uint8_t *rows){
createChar(char_num, rows);
}
void HC_LiquidCrystal_I2C::setBacklight(uint8_t new_val){
if (new_val) {
backlight(); // turn backlight on
} else {
noBacklight(); // turn backlight off
}
}
void HC_LiquidCrystal_I2C::printstr(const char c[]){
//This function is not identical to the function used for "real" I2C displays
//it's here so the user sketch doesn't have to be changed
print(c);
}

164
Examples/LCDTest/HC_LiquidCrystal_I2C/HC_LiquidCrystal_I2C.h
View file

@ -1,164 +0,0 @@
#ifndef FDB_LIQUID_CRYSTAL_I2C_H
#define FDB_LIQUID_CRYSTAL_I2C_H
#include <inttypes.h>
#include <Print.h>
// commands
#define LCD_CLEARDISPLAY 0x01
#define LCD_RETURNHOME 0x02
#define LCD_ENTRYMODESET 0x04
#define LCD_DISPLAYCONTROL 0x08
#define LCD_CURSORSHIFT 0x10
#define LCD_FUNCTIONSET 0x20
#define LCD_SETCGRAMADDR 0x40
#define LCD_SETDDRAMADDR 0x80
// flags for display entry mode
#define LCD_ENTRYRIGHT 0x00
#define LCD_ENTRYLEFT 0x02
#define LCD_ENTRYSHIFTINCREMENT 0x01
#define LCD_ENTRYSHIFTDECREMENT 0x00
// flags for display on/off control
#define LCD_DISPLAYON 0x04
#define LCD_DISPLAYOFF 0x00
#define LCD_CURSORON 0x02
#define LCD_CURSOROFF 0x00
#define LCD_BLINKON 0x01
#define LCD_BLINKOFF 0x00
// flags for display/cursor shift
#define LCD_DISPLAYMOVE 0x08
#define LCD_CURSORMOVE 0x00
#define LCD_MOVERIGHT 0x04
#define LCD_MOVELEFT 0x00
// flags for function set
#define LCD_8BITMODE 0x10
#define LCD_4BITMODE 0x00
#define LCD_2LINE 0x08
#define LCD_1LINE 0x00
#define LCD_5x10DOTS 0x04
#define LCD_5x8DOTS 0x00
// flags for backlight control
#define LCD_BACKLIGHT 0x08
#define LCD_NOBACKLIGHT 0x00
#define En B00000100 // Enable bit
#define Rw B00000010 // Read/Write bit
#define Rs B00000001 // Register select bit
/**
* This is the driver for the Liquid Crystal LCD displays that use the I2C bus.
*
* After creating an instance of this class, first call begin() before anything else.
* The backlight is on by default, since that is the most likely operating mode in
* most cases.
*/
class HC_LiquidCrystal_I2C : public Print {
public:
/**
* Constructor
*
* @param lcd_addr I2C slave address of the LCD display. Most likely printed on the
* LCD circuit board, or look in the supplied LCD documentation.
* @param lcd_cols Number of columns your LCD display has.
* @param lcd_rows Number of rows your LCD display has.
* @param charsize The size in dots that the display has, use LCD_5x10DOTS or LCD_5x8DOTS.
*/
HC_LiquidCrystal_I2C(uint8_t lcd_addr, uint8_t lcd_cols, uint8_t lcd_rows, uint8_t charsize = LCD_5x8DOTS);
/**
* Set the LCD display in the correct begin state, must be called before anything else is done.
*/
void begin();
/**
* Remove all the characters currently shown. Next print/write operation will start
* from the first position on LCD display.
*/
void clear();
/**
* Next print/write operation will will start from the first position on the LCD display.
*/
void home();
/**
* Do not show any characters on the LCD display. Backlight state will remain unchanged.
* Also all characters written on the display will return, when the display in enabled again.
*/
void noDisplay();
/**
* Show the characters on the LCD display, this is the normal behaviour. This method should
* only be used after noDisplay() has been used.
*/
void display();
/**
* Do not blink the cursor indicator.
*/
void noBlink();
/**
* Start blinking the cursor indicator.
*/
void blink();
/**
* Do not show a cursor indicator.
*/
void noCursor();
/**
* Show a cursor indicator, cursor can blink on not blink. Use the
* methods blink() and noBlink() for changing cursor blink.
*/
void cursor();
void scrollDisplayLeft();
void scrollDisplayRight();
void printLeft();
void printRight();
void leftToRight();
void rightToLeft();
void shiftIncrement();
void shiftDecrement();
void noBacklight();
void backlight();
void autoscroll();
void noAutoscroll();
void createChar(uint8_t, uint8_t[]);
void setCursor(uint8_t, uint8_t);
virtual size_t write(uint8_t);
void command(uint8_t);
inline void blink_on() { blink(); }
inline void blink_off() { noBlink(); }
inline void cursor_on() { cursor(); }
inline void cursor_off() { noCursor(); }
// Compatibility API function aliases
void setBacklight(uint8_t new_val); // alias for backlight() and nobacklight()
void load_custom_character(uint8_t char_num, uint8_t *rows); // alias for createChar()
void printstr(const char[]);
private:
void send(uint8_t, uint8_t);
void write4bits(uint8_t);
void expanderWrite(uint8_t);
void pulseEnable(uint8_t);
uint8_t _addr;
uint8_t _displayfunction;
uint8_t _displaycontrol;
uint8_t _displaymode;
uint8_t _cols;
uint8_t _rows;
uint8_t _charsize;
uint8_t _backlightval;
};
#endif // FDB_LIQUID_CRYSTAL_I2C_H

9
Examples/LCDTest/HC_LiquidCrystal_I2C/README.md
View file

@ -1,9 +0,0 @@
# Installation #
Create a new folder called "HC_LiquidCrystal_I2C" under the folder named "libraries" in your Arduino sketchbook folder.
Create the folder "libraries" in case it does not exist yet. Place all the files in the "HC_LiquidCrystal_I2C" folder.
# Usage #
To use the library in your own sketch, select it from *Sketch > Import Library*.
-------------------------------------------------------------------------------------------------------------------
This library is based on work done by DFROBOT (www.dfrobot.com).

32
Examples/LCDTest/HC_LiquidCrystal_I2C/examples/BlinkingCursor/BlinkingCursor.ino
View file

@ -1,32 +0,0 @@
#include <Wire.h>
#include <HC_LiquidCrystal_I2C.h>
// Set the LCD address to 0x27 for a 16 chars and 2 line display
HC_LiquidCrystal_I2C lcd(0x27, 16, 2);
void setup()
{
// initialize the LCD
lcd.begin();
}
void loop()
{
bool blinking = true;
lcd.cursor();
while (1) {
if (blinking) {
lcd.clear();
lcd.print("No cursor blink");
lcd.noBlink();
blinking = false;
} else {
lcd.clear();
lcd.print("Cursor blink");
lcd.blink();
blinking = true;
}
delay(4000);
}
}

65
Examples/LCDTest/HC_LiquidCrystal_I2C/examples/CustomChars/CustomChars.ino
View file

@ -1,65 +0,0 @@
#include <Wire.h>
#include <HC_LiquidCrystal_I2C.h>
uint8_t bell[8] = {0x4, 0xe, 0xe, 0xe, 0x1f, 0x0, 0x4};
uint8_t note[8] = {0x2, 0x3, 0x2, 0xe, 0x1e, 0xc, 0x0};
uint8_t clock[8] = {0x0, 0xe, 0x15, 0x17, 0x11, 0xe, 0x0};
uint8_t heart[8] = {0x0, 0xa, 0x1f, 0x1f, 0xe, 0x4, 0x0};
uint8_t duck[8] = {0x0, 0xc, 0x1d, 0xf, 0xf, 0x6, 0x0};
uint8_t check[8] = {0x0, 0x1 ,0x3, 0x16, 0x1c, 0x8, 0x0};
uint8_t cross[8] = {0x0, 0x1b, 0xe, 0x4, 0xe, 0x1b, 0x0};
uint8_t retarrow[8] = { 0x1, 0x1, 0x5, 0x9, 0x1f, 0x8, 0x4};
// Set the LCD address to 0x27 for a 16 chars and 2 line display
HC_LiquidCrystal_I2C lcd(0x27, 16, 2);
void setup()
{
lcd.begin();
lcd.backlight();
lcd.createChar(0, bell);
lcd.createChar(1, note);
lcd.createChar(2, clock);
lcd.createChar(3, heart);
lcd.createChar(4, duck);
lcd.createChar(5, check);
lcd.createChar(6, cross);
lcd.createChar(7, retarrow);
lcd.home();
lcd.print("Hello world...");
lcd.setCursor(0, 1);
lcd.print(" i ");
lcd.write(3);
lcd.print(" arduinos!");
delay(5000);
displayKeyCodes();
}
// display all keycodes
void displayKeyCodes(void) {
uint8_t i = 0;
while (1) {
lcd.clear();
lcd.print("Codes 0x");
lcd.print(i, HEX);
lcd.print("-0x");
lcd.print(i + 16, HEX);
lcd.setCursor(0, 1);
for (int j = 0; j < 16; j++) {
lcd.write(i + j);
}
i += 16;
delay(4000);
}
}
void loop()
{
// Do nothing here...
}

20
Examples/LCDTest/HC_LiquidCrystal_I2C/examples/HelloWorld/HelloWorld.ino
View file

@ -1,20 +0,0 @@
#include <Wire.h>
#include <HC_LiquidCrystal_I2C.h>
// Set the LCD address to 0x27 for a 16 chars and 2 line display
HC_LiquidCrystal_I2C lcd(0x27, 16, 2);
void setup()
{
// initialize the LCD
lcd.begin();
// Turn on the blacklight and print a message.
lcd.backlight();
lcd.print("Hello, world!");
}
void loop()
{
// Do nothing here...
}

34
Examples/LCDTest/HC_LiquidCrystal_I2C/examples/SerialDisplay/SerialDisplay.ino
View file

@ -1,34 +0,0 @@
/**
* Displays text sent over the serial port (e.g. from the Serial Monitor) on
* an attached LCD.
*/
#include <Wire.h>
#include <HC_LiquidCrystal_I2C.h>
// Set the LCD address to 0x27 for a 16 chars and 2 line display
HC_LiquidCrystal_I2C lcd(0x27, 16, 2);
void setup()
{
lcd.begin();
lcd.backlight();
// Initialize the serial port at a speed of 9600 baud
Serial.begin(9600);
}
void loop()
{
// If characters arrived over the serial port...
if (Serial.available()) {
// Wait a bit for the entire message to arrive
delay(100);
// Clear the screen
lcd.clear();
// Write all characters received with the serial port to the LCD.
while (Serial.available() > 0) {
lcd.write(Serial.read());
}
}
}

46
Examples/LCDTest/HC_LiquidCrystal_I2C/keywords.txt
View file

@ -1,46 +0,0 @@
###########################################
# Syntax Coloring Map For HC_LiquidCrystal_I2C
###########################################
###########################################
# Datatypes (KEYWORD1)
###########################################
HC_LiquidCrystal_I2C KEYWORD1
###########################################
# Methods and Functions (KEYWORD2)
###########################################
init KEYWORD2
begin KEYWORD2
clear KEYWORD2
home KEYWORD2
noDisplay KEYWORD2
display KEYWORD2
noBlink KEYWORD2
blink KEYWORD2
noCursor KEYWORD2
cursor KEYWORD2
scrollDisplayLeft KEYWORD2
scrollDisplayRight KEYWORD2
leftToRight KEYWORD2
rightToLeft KEYWORD2
shiftIncrement KEYWORD2
shiftDecrement KEYWORD2
noBacklight KEYWORD2
backlight KEYWORD2
autoscroll KEYWORD2
noAutoscroll KEYWORD2
createChar KEYWORD2
setCursor KEYWORD2
print KEYWORD2
blink_on KEYWORD2
blink_off KEYWORD2
cursor_on KEYWORD2
cursor_off KEYWORD2
setBacklight KEYWORD2
load_custom_character KEYWORD2
printstr KEYWORD2
###########################################
# Constants (LITERAL1)
###########################################

107
Examples/LCDTest/LCDTest.ino
View file

@ -1,107 +0,0 @@
/* FILE: ARD_LCD_HCMODU0010_I2C_Hello_World_Example
DATE: 24/05/13
VERSION: 0.1
This is a simple example of how to use the Hobby Components 20 x 4 line
I2C LCD module (HCMODU0010). To use this module you will require the
appropriate HC_LiquidCrystal_I2C library, which can be downloaded from our support
forum:
http://forum.hobbycomponents.com
This code also demonstrates the correct pin assignment for the LCD. When you
run this program you should see a greeting message appear on the display.
DEVICE PINOUT (SPI Interface):
PIN 1: GND
PIN 2: +5V
PIN 3: SDA - Connect to Arduino analogue PIN 4
PIN 4: SCL - Connect to Arduino analogue PIN 5
You may copy, alter and reuse this code in any way you like, but please leave
reference to HobbyComponents.com in your comments if you redistribute this code.
This software may not be used directly for the purpose of selling products that
directly compete with Hobby Components Ltd's own range of products.
THIS SOFTWARE IS PROVIDED "AS IS". HOBBY COMPONENTS LTD MAKES NO WARRANTIES, WHETHER
EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ACCURACY OR LACK OF NEGLIGENCE.
HOBBY COMPONENTS SHALL NOT, IN ANY CIRCUMSTANCES, BE LIABLE FOR ANY DAMAGES,
INCLUDING, BUT NOT LIMITED TO, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR ANY
REASON WHATSOEVER.
*/
/* Include the SPI/IIC Library */
#include <Wire.h>
#include "HC_LiquidCrystal_I2C.h"
/* Create some custom graphic characters to make a simple border */
uint8_t TopLeftCorner[] = {0x00,0x00,0x0f,0x08,0x0b,0x0a,0x0a,0x0a};
uint8_t TopRightCorner[] = {0x00,0x00,0x1e,0x02,0x1a,0x0a,0x0a,0x0a};
uint8_t BottomLeftCorner[] = {0x0a,0x0a,0x0b,0x08,0x0f,0x00,0x00,0x00};
uint8_t BottomRightCorner[] = {0x0a,0x0a,0x1a,0x02,0x1e,0x00,0x00,0x00};
uint8_t VerticalBar[] = {0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a};
/* Initialise the LiquidCrystal library. Note that the displays will have a default I2C
address of either 0x27 or 0x3F. Uncomment one of the lines below depending on
the address of your module. */
//HC_LiquidCrystal_I2C lcd(0x27,20,4);
HC_LiquidCrystal_I2C lcd(0x3F,20,4);
void setup()
{
/* Initialise the LCD */
lcd.begin();
/* Transfer the custom characters into the LCD's memory */
lcd.createChar(0, TopLeftCorner);
lcd.createChar(1, TopRightCorner);
lcd.createChar(2, BottomLeftCorner);
lcd.createChar(3, BottomRightCorner);
lcd.createChar(4, VerticalBar);
}
/* Main program loop */
void loop()
{
/* Make sure the backlight is turned on */
lcd.backlight();
/* Use the custom graphic characters to draw a border */
lcd.setCursor(0, 0);
lcd.write(0); //Write the top left graphic
lcd.print("==================");
lcd.write(1); //Write the top right graphic
lcd.setCursor(0, 1);
lcd.write(4); //Write the vertical bar graphic
lcd.setCursor(0, 2);
lcd.write(4); //Write the vertical bar graphic
lcd.setCursor(19, 1);
lcd.write(4); //Write the vertical bar graphic
lcd.setCursor(19, 2);
lcd.write(4); //Write the vertical bar graphic
lcd.setCursor(0, 3);
lcd.write(2); //Write the bottom left graphic
lcd.print("==================");
lcd.write(3); //Write the bottom right graphic
/* Display some text inside the border */
while (1)
{
lcd.setCursor(2,1);
lcd.print("HOBBY COMPONENTS");
lcd.setCursor(2,2);
lcd.print("**HELLO WORLD**");
delay(500);
lcd.setCursor(2,1);
lcd.print(" ");
lcd.setCursor(2,2);
lcd.print(" ");
delay(500);
}
}

88
Examples/RFM95-Client/rf95_client/rf95_client.ino
View file

@ -1,88 +0,0 @@
// rf95_client.pde
// -*- mode: C++ -*-
// Example sketch showing how to create a simple messageing client
// with the RH_RF95 class. RH_RF95 class does not provide for addressing or
// reliability, so you should only use RH_RF95 if you do not need the higher
// level messaging abilities.
// It is designed to work with the other example rf95_server
// Tested with Anarduino MiniWirelessLoRa, Rocket Scream Mini Ultra Pro with
// the RFM95W, Adafruit Feather M0 with RFM95
#include <SPI.h>
#include <RH_RF95.h>
// Singleton instance of the radio driver
RH_RF95 rf95(10, 2);
//RH_RF95 rf95(5, 2); // Rocket Scream Mini Ultra Pro with the RFM95W
//RH_RF95 rf95(8, 3); // Adafruit Feather M0 with RFM95
// Need this on Arduino Zero with SerialUSB port (eg RocketScream Mini Ultra Pro)
//#define Serial SerialUSB
void setup()
{
// Rocket Scream Mini Ultra Pro with the RFM95W only:
// Ensure serial flash is not interfering with radio communication on SPI bus
// pinMode(4, OUTPUT);
// digitalWrite(4, HIGH);
Serial.begin(9600);
while (!Serial) ; // Wait for serial port to be available
if (!rf95.init()) {
Serial.println("init failed");
while (true);
}
// Defaults after init are 434.0MHz, 13dBm, Bw = 125 kHz, Cr = 4/5, Sf = 128chips/symbol, CRC on
// The default transmitter power is 13dBm, using PA_BOOST.
// If you are using RFM95/96/97/98 modules which uses the PA_BOOST transmitter pin, then
// you can set transmitter powers from 5 to 23 dBm:
// driver.setTxPower(23, false);
// If you are using Modtronix inAir4 or inAir9,or any other module which uses the
// transmitter RFO pins and not the PA_BOOST pins
// then you can configure the power transmitter power for -1 to 14 dBm and with useRFO true.
// Failure to do that will result in extremely low transmit powers.
// driver.setTxPower(14, true);
rf95.setFrequency(868.0);
delay(100);
}
void loop()
{
Serial.println("Sending to rf95_server");
// Send a message to rf95_server
uint8_t data[] = "Hello Brian!";
rf95.send(data, sizeof(data));
rf95.waitPacketSent();
Serial.println("Sending complete");
// Now wait for a reply
uint8_t buf[RH_RF95_MAX_MESSAGE_LEN];
uint8_t len = sizeof(buf);
if (rf95.waitAvailableTimeout(3000))
{
// Should be a reply message for us now
if (rf95.recv(buf, &len))
{
Serial.print("got reply: ");
Serial.println((char*)buf);
Serial.print("RSSI: ");
Serial.println(rf95.lastRssi(), DEC);
}
else
{
Serial.println("recv failed");
}
}
else
{
Serial.println("No reply, is rf95_server running?");
}
delay(400);
}

85
Examples/RFM95-Server/RFM95-Server.ino
View file

@ -1,85 +0,0 @@
// rf95_server.pde
// -*- mode: C++ -*-
// Example sketch showing how to create a simple messageing server
// with the RH_RF95 class. RH_RF95 class does not provide for addressing or
// reliability, so you should only use RH_RF95 if you do not need the higher
// level messaging abilities.
// It is designed to work with the other example rf95_client
// Tested with Anarduino MiniWirelessLoRa, Rocket Scream Mini Ultra Pro with
// the RFM95W, Adafruit Feather M0 with RFM95
#include <SPI.h>
#include <RH_RF95.h>
// Singleton instance of the radio driver
RH_RF95 rf95(10, 2);
//RH_RF95 rf95(5, 2); // Rocket Scream Mini Ultra Pro with the RFM95W
//RH_RF95 rf95(8, 3); // Adafruit Feather M0 with RFM95
// Need this on Arduino Zero with SerialUSB port (eg RocketScream Mini Ultra Pro)
//#define Serial SerialUSB
int led = 9;
void setup()
{
// Rocket Scream Mini Ultra Pro with the RFM95W only:
// Ensure serial flash is not interfering with radio communication on SPI bus
// pinMode(4, OUTPUT);
// digitalWrite(4, HIGH);
pinMode(led, OUTPUT);
Serial.begin(9600);
while (!Serial) ; // Wait for serial port to be available
if (!rf95.init()) {
Serial.println("rf95().init failed");
while (true) ;
}
// Defaults after init are 434.0MHz, 13dBm, Bw = 125 kHz, Cr = 4/5, Sf = 128chips/symbol, CRC on
// The default transmitter power is 13dBm, using PA_BOOST.
// If you are using RFM95/96/97/98 modules which uses the PA_BOOST transmitter pin, then
// you can set transmitter powers from 5 to 23 dBm:
// driver.setTxPower(23, false);
// If you are using Modtronix inAir4 or inAir9,or any other module which uses the
// transmitter RFO pins and not the PA_BOOST pins
// then you can configure the power transmitter power for -1 to 14 dBm and with useRFO true.
// Failure to do that will result in extremely low transmit powers.
// driver.setTxPower(14, true);
rf95.setFrequency(868.0);
delay(100);
}
void loop()
{
if (rf95.available())
{
// Should be a message for us now
uint8_t buf[RH_RF95_MAX_MESSAGE_LEN];
uint8_t len = sizeof(buf);
if (rf95.recv(buf, &len))
{
digitalWrite(led, HIGH);
// RH_RF95::printBuffer("request: ", buf, len);
Serial.print("got request: ");
Serial.println((char*)buf);
// Serial.print("RSSI: ");
// Serial.println(rf95.lastRssi(), DEC);
// Send a reply
uint8_t data[] = "And hello back to you";
rf95.send(data, sizeof(data));
rf95.waitPacketSent();
Serial.println("Sent a reply");
digitalWrite(led, LOW);
}
else
{
Serial.println("recv failed");
}
}
}

9
Examples/UNO_rf95_client/UNO_rf95_client.ino
View file

@ -1,6 +1,6 @@
// rf95_client.pde
// -*- mode: C++ -*-
// Example sketch showing how to create a simple messaging client
// Example sketch showing how to create a simple messageing client
// with the RH_RF95 class. RH_RF95 class does not provide for addressing or
// reliability, so you should only use RH_RF95 if you do not need the higher
// level messaging abilities.
@ -12,9 +12,6 @@
#include <RH_RF95.h>
// Singleton instance of the radio driver
// Wemos D1 R2
//RH_RF95 rf95(8, 2);
// Arduino Uno
RH_RF95 rf95(10, 2);
int led = 7; // do not use SPI pins
@ -24,7 +21,7 @@ void setup()
pinMode(led, OUTPUT);
Serial.begin(9600);
//while (!Serial) ; // Wait for serial port to be available
while (!Serial) ; // Wait for serial port to be available
Serial.println("Client starting");
@ -83,3 +80,5 @@ void loop()
digitalWrite(led, LOW);
delay(400);
}