Sondervick/Profielwerkstuk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Store in GIT

Browse Source
This commit is contained in:
kennyboy55
2026-06-17 12:03:21 +02:00
parent da3dafa12f
commit 66ae70dcb2
31 changed files with 1898 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Code/PWS.ino
+405
View File
@@ -0,0 +1,405 @@
#include <Weer.h>
#include <Kamer.h>
#include <Verwarming.h>
#include <Mens.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);
//WEER
Weer weer = Weer();
//KAMERS
Kamer woonkamer = Kamer(); //nr 1
Kamer keuken = Kamer(); //nr 2
Kamer slaapkamer1 = Kamer(); //nr 3
Kamer slaapkamer2 = Kamer(); //nr 4
Kamer badkamer = Kamer(); //nr 5
Kamer zolderkamer = Kamer(); //nr 6
//VERWARMINGEN
Verwarming v_woonkamer = Verwarming(); boolean v_woonkamer_on = false;
Verwarming v_keuken = Verwarming(); boolean v_keuken_on = false;
Verwarming v_slaapkamer1 = Verwarming(); boolean v_slaapkamer1_on = false;
Verwarming v_slaapkamer2 = Verwarming(); boolean v_slaapkamer2_on = false;
Verwarming v_badkamer = Verwarming(); boolean v_badkamer_on = false;
Verwarming v_zolderkamer = Verwarming(); boolean v_zolderkamer_on = false;
//MENSEN
Mens michel = Mens();
Mens annemiek = Mens();
Mens kenneth = Mens();
//TIMER
int timer = 0;
void setup()
{
//WOONKAMER
woonkamer.setTemp(15);
woonkamer.setVolume(72);
woonkamer.setSurfaceArea(45, 20);
v_woonkamer.setLed(0);
v_woonkamer.setWattage(2000);
v_woonkamer.setVolume(woonkamer.getVolume());
//KEUKEN
keuken.setTemp(15);
keuken.setVolume(18);
keuken.setSurfaceArea(15, 6);
v_keuken.setLed(1);
v_keuken.setWattage(500);
v_keuken.setVolume(keuken.getVolume());
//SLAAPKAMER1
slaapkamer1.setTemp(15);
slaapkamer1.setVolume(50);
slaapkamer1.setSurfaceArea(20, 3);
v_slaapkamer1.setLed(2);
v_slaapkamer1.setWattage(500);
v_slaapkamer1.setVolume(slaapkamer1.getVolume());
//SLAAPKAMER2
slaapkamer2.setTemp(15);
slaapkamer2.setVolume(30);
slaapkamer2.setSurfaceArea(15, 3);
v_slaapkamer2.setLed(3);
v_slaapkamer2.setWattage(500);
v_slaapkamer2.setVolume(slaapkamer2.getVolume());
//BADKAMER
badkamer.setTemp(15);
badkamer.setVolume(30);
badkamer.setSurfaceArea(15, 2);
v_badkamer.setLed(4);
v_badkamer.setWattage(500);
v_badkamer.setVolume(badkamer.getVolume());
//ZOLDERKAMER
zolderkamer.setTemp(15);
zolderkamer.setVolume(20);
zolderkamer.setSurfaceArea(22, 4);
v_zolderkamer.setLed(5);
v_zolderkamer.setWattage(500);
v_zolderkamer.setVolume(zolderkamer.getVolume());
//KENNETH
int pattern1[80][3] = { {0,4,400}, {410,5,430}, {450,1,510} };
kenneth.setPattern(pattern1, 80);
//MICHEL
int pattern2[80][3] = { {0,3,350}, {360,5,380}, {390,1,400} };
michel.setPattern(pattern2, 80);
//ANNEMIEK
int pattern3[80][3] = { {0,3,380}, {390,5,410}, {420,1,600} };
annemiek.setPattern(pattern3, 80);
//SERIELE VERBINDING STARTEN
Serial.begin(9600);
Serial.println("\t");
Serial.println("Serial connection started on 9600 baud");
Serial.println("\t");
//LCD WEERGAVE
lcd.init();
lcd.setBacklight(HIGH);
}
void loop()
{
//WEEER
weer.calcTemp(timer);
double temp = weer.getTemp();
//DEBUGGING
Serial.println("\t");
Serial.print("\t");
Serial.println(timer);
Serial.println("----------------------");
Serial.print("Buiten:\t\t");
Serial.println(temp,4);
//MENSEN
int timeToEnter_kenneth[2] = {kenneth.getTimeToEnter(timer)};
int timeToEnter_michel[2] = {michel.getTimeToEnter(timer)};
int timeToEnter_annemiek[2] = {annemiek.getTimeToEnter(timer)};
int timeToLeave_kenneth[2] = {kenneth.getTimeToLeave(timer)};
int timeToLeave_michel[2] = {michel.getTimeToLeave(timer)};
int timeToLeave_annemiek[2] = {annemiek.getTimeToLeave(timer)};
int room_enter_kenneth = timeToEnter_kenneth[1];
int room_enter_annemiek = timeToEnter_annemiek[1];
int room_enter_michel = timeToEnter_michel[1];
int room_leave_kenneth = timeToLeave_kenneth[1];
int room_leave_annemiek = timeToLeave_annemiek[1];
int room_leave_michel = timeToLeave_michel[1];
int enter_kenneth = timeToEnter_kenneth[0];
int enter_michel = timeToEnter_michel[0];
int enter_annemiek = timeToEnter_annemiek[0];
int leave_kenneth = timeToLeave_kenneth[0];
int leave_michel = timeToLeave_michel[0];
int leave_annemiek = timeToLeave_annemiek[0];
//WOONKAMER
woonkamer.calcTemp(temp);
double temp_woonkamer = woonkamer.getTemp();
v_woonkamer.setTemp(temp_woonkamer);
temp_woonkamer = v_woonkamer.getTemp();
woonkamer.setTemp(temp_woonkamer);
double heat_woonkamer = woonkamer.getHeatFlow();
int toTemp_woonkamer = v_woonkamer.getTimeToTemp(heat_woonkamer, 21);
if(room_enter_kenneth == 1 || room_enter_michel == 1 || room_enter_michel == 1){
v_woonkamer_on = true;
}
if(room_leave_kenneth == 1 || room_leave_michel == 1 || room_leave_michel == 1){
v_woonkamer_on = false;
}
if(v_woonkamer_on){
v_woonkamer.keepTemp(21);
}
bool state_woonkamer = v_woonkamer.getState();
Serial.print("Woonkamer:\t");
Serial.println(temp_woonkamer,4);
Serial.print("Verwarming:\t");
if(state_woonkamer){
Serial.println("On");
}
else {
Serial.println("Off");
}
Serial.print("Tijd tot 21:\t");
Serial.println(toTemp_woonkamer);
//KEUKEN
keuken.calcTemp(temp);
double temp_keuken = keuken.getTemp();
v_keuken.setTemp(temp_keuken);
temp_keuken = v_keuken.getTemp();
keuken.setTemp(temp_keuken);
double heat_keuken = keuken.getHeatFlow();
int toTemp_keuken = v_keuken.getTimeToTemp(heat_keuken, 21);
if(room_enter_kenneth == 1 || room_enter_michel == 1 || room_enter_michel == 1){
v_keuken_on = true;
}
if(room_leave_kenneth == 1 || room_leave_michel == 1 || room_leave_michel == 1){
v_keuken_on = false;
}
if(v_keuken_on){
v_keuken.keepTemp(21);
}
bool state_keuken = v_keuken.getState();
Serial.print("Keuken:\t");
Serial.println(temp_keuken,4);
Serial.print("Verwarming:\t");
if(state_keuken){
Serial.println("On");
}
else {
Serial.println("Off");
}
Serial.print("Tijd tot 21:\t");
Serial.println(toTemp_keuken);
//SLAAPKAMER1
slaapkamer1.calcTemp(temp);
double temp_slaapkamer1 = slaapkamer1.getTemp();
v_slaapkamer1.setTemp(temp_slaapkamer1);
temp_slaapkamer1 = v_slaapkamer1.getTemp();
slaapkamer1.setTemp(temp_slaapkamer1);
double heat_slaapkamer1 = slaapkamer1.getHeatFlow();
int toTemp_slaapkamer1 = v_slaapkamer1.getTimeToTemp(heat_slaapkamer1, 20);
if(room_enter_kenneth == 1 || room_enter_michel == 1 || room_enter_michel == 1){
v_slaapkamer1_on = true;
}
if(room_leave_kenneth == 1 || room_leave_michel == 1 || room_leave_michel == 1){
v_slaapkamer1_on = false;
}
if(v_slaapkamer1_on){
v_slaapkamer1.keepTemp(20);
}
bool state_slaapkamer1 = v_slaapkamer1.getState();
Serial.print("Slaapkamer1:\t");
Serial.println(temp_slaapkamer1,4);
Serial.print("Verwarming:\t");
if(state_slaapkamer1){
Serial.println("On");
}
else {
Serial.println("Off");
}
Serial.print("Tijd tot 20:\t");
Serial.println(toTemp_slaapkamer1);
//SLAAPKAMER1
slaapkamer2.calcTemp(temp);
double temp_slaapkamer2 = slaapkamer2.getTemp();
v_slaapkamer2.setTemp(temp_slaapkamer2);
temp_slaapkamer2 = v_slaapkamer2.getTemp();
slaapkamer2.setTemp(temp_slaapkamer2);
double heat_slaapkamer2 = slaapkamer2.getHeatFlow();
int toTemp_slaapkamer2 = v_slaapkamer2.getTimeToTemp(heat_slaapkamer2, 20);
if(room_enter_kenneth == 1 || room_enter_michel == 1 || room_enter_michel == 1){
v_slaapkamer2_on = true;
}
if(room_leave_kenneth == 1 || room_leave_michel == 1 || room_leave_michel == 1){
v_slaapkamer2_on = false;
}
if(v_slaapkamer2_on){
v_slaapkamer2.keepTemp(20);
}
bool state_slaapkamer2 = v_slaapkamer2.getState();
Serial.print("Slaapkamer2:\t");
Serial.println(temp_slaapkamer2,4);
Serial.print("Verwarming:\t");
if(state_slaapkamer2){
Serial.println("On");
}
else {
Serial.println("Off");
}
Serial.print("Tijd tot 20:\t");
Serial.println(toTemp_slaapkamer2);
//BADKAMER
badkamer.calcTemp(temp);
double temp_badkamer = badkamer.getTemp();
v_badkamer.setTemp(temp_badkamer);
temp_badkamer = v_badkamer.getTemp();
slaapkamer1.setTemp(temp_slaapkamer1);
double heat_badkamer = badkamer.getHeatFlow();
int toTemp_badkamer = v_badkamer.getTimeToTemp(heat_badkamer, 23);
if(room_enter_kenneth == 1 || room_enter_michel == 1 || room_enter_michel == 1){
v_badkamer_on = true;
}
if(room_leave_kenneth == 1 || room_leave_michel == 1 || room_leave_michel == 1){
v_badkamer_on = false;
}
if(v_badkamer_on){
v_slaapkamer1.keepTemp(23);
}
bool state_badkamer = v_badkamer.getState();
Serial.print("Badkamer:\t");
Serial.println(temp_badkamer,4);
Serial.print("Verwarming:\t");
if(state_badkamer){
Serial.println("On");
}
else {
Serial.println("Off");
}
Serial.print("Tijd tot 23:\t");
Serial.println(toTemp_badkamer);
//ZOLDERKAMER
zolderkamer.calcTemp(temp);
double temp_zolderkamer = zolderkamer.getTemp();
v_zolderkamer.setTemp(temp_zolderkamer);
temp_zolderkamer = v_zolderkamer.getTemp();
slaapkamer1.setTemp(temp_slaapkamer1);
double heat_zolderkamer = zolderkamer.getHeatFlow();
int toTemp_zolderkamer = v_zolderkamer.getTimeToTemp(heat_zolderkamer, 18);
if(room_enter_kenneth == 1 || room_enter_michel == 1 || room_enter_michel == 1){
v_zolderkamer_on = true;
}
if(room_leave_kenneth == 1 || room_leave_michel == 1 || room_leave_michel == 1){
v_zolderkamer_on = false;
}
if(v_zolderkamer_on){
v_slaapkamer1.keepTemp(18);
}
bool state_zolderkamer = v_zolderkamer.getState();
Serial.print("Zolderkamer:\t");
Serial.println(temp_zolderkamer,4);
Serial.print("Verwarming:\t");
if(state_zolderkamer){
Serial.println("On");
}
else {
Serial.println("Off");
}
Serial.print("Tijd tot 18:\t");
Serial.println(toTemp_zolderkamer);
//SCHERM
lcd.setCursor(0,0);
lcd.print("Timer: ");
lcd.print(timer);
lcd.setCursor(0,1);
lcd.print("Buitentemp: ");
lcd.print(temp);
//TIMER
++timer;
delay(1000);
}
Code/libraries/Kamer/Kamer.cpp
+96
View File
@@ -0,0 +1,96 @@
/*
Kamer.cpp
Copyright (c) 2014 Kenneth van Ewijk. All right reserved.
*/
// include this library's description file
#include "Kamer.h"
Kamer::Kamer(void)
{
// initialize this instance's variables
volume = 0;
temp = 0;
wallSurface = 0;
windowSurface = 0;
surfaceArea = 0;
heatFlow = 0;
deltaTemp = 0;
}
//Set Room Properties
void Kamer::setVolume(int givenVolume)
{
volume = givenVolume;
}
void Kamer::setTemp(double givenTemp)
{
temp = givenTemp;
}
void Kamer::setSurfaceArea(int givenWall, int givenWindow)
{
wallSurface = givenWall;
windowSurface = givenWindow;
surfaceArea = wallSurface + windowSurface;
}
//Calc Room Properties
void Kamer::calcTemp(int outsideTemp)
{
calcHeatFlow(outsideTemp);
deltaTemp = heatFlow / ( (volume * 1.43) * 920);
double newTemp = temp - deltaTemp;
temp = newTemp;
}
void Kamer::calcHeatFlow(int outsideTemp)
{
double deltaTemp2 = temp - outsideTemp;
//Make sure deltaTemp is positive
double heatFlowWall = 0.6 * wallSurface * (deltaTemp2 / 20);
double heatFlowIsolation = 0.08 * wallSurface * (deltaTemp2 / 0.5);
double heatFlowWallTotal = 1 / ( (1 / heatFlowWall) + (1 / heatFlowIsolation) );
double heatFlowWindow = 0.98 * windowSurface * (deltaTemp2 / 12);
double heatFlowAir = 0.025 * windowSurface * (deltaTemp2 / 12);
double heatFlowWindowTotal = 1 / ( (1 / heatFlowWindow) + (1 / heatFlowAir) );
heatFlow = heatFlowWindowTotal + heatFlowWallTotal;
heatFlow = heatFlow * 60;
}
//Get Room Properties
int Kamer::getVolume(void)
{
return volume;
}
double Kamer::getTemp(void)
{
return temp;
}
int Kamer::getSurfaceArea(void)
{
return surfaceArea;
}
double Kamer::getHeatFlow(void)
{
return heatFlow;
}
double Kamer::getDeltaTemp(void)
{
return deltaTemp;
}
Code/libraries/Kamer/Kamer.h
+37
View File
@@ -0,0 +1,37 @@
/*
Kamer.h
Copyright (c) 2014 Kenneth van Ewijk. All right reserved.
*/
// ensure this library description is only included once
#ifndef Kamer_h
#define Kamer_h
// library interface description
class Kamer
{
// user-accessible "public" interface
public:
Kamer(void);
void setVolume(int);
void setTemp(double);
void setSurfaceArea(int, int);
void calcTemp(int);
int getVolume(void);
double getTemp(void);
int getSurfaceArea(void);
double getHeatFlow(void);
double getDeltaTemp(void);
// code-accessible "private" interface
private:
void calcHeatFlow(int);
int volume;
double temp;
int wallSurface;
int windowSurface;
int surfaceArea;
double heatFlow;
double deltaTemp;
};
#endif
Code/libraries/Kamer/examples/usage/usage.pde
+56
View File
@@ -0,0 +1,56 @@
#include <Kamer.h>
#include <stdlib.h>
#include <math.h>
#define _USE_MATH_DEFINES
// Library for "Kamer"
// by Kenneth van Ewijk <http://www.kennyboy.nl>
// Demostrates how to do something with the Kamer library
// Created 16 February 2014
Kamer slaapkamer = Kamer();
int volume;
int temp;
int surfaceArea;
int outsideTemp;
int timer;
int dag = 0;
int rd = rand();
int eq;
int amp;
void setup()
{
timer = 0;
slaapkamer.setVolume(40);
slaapkamer.setTemp(21);
slaapkamer.setSurfaceArea(15, 3);
}
void loop()
{
int uur = timer / (3600);
int newdag = uur / 24;
if(newdag > dag){
rd = rand();
dag = newdag;
eq = 9- ((1/6) * dag) + (5 * rd);
amp = (rd * 9) + 3;
}
int per = (2 * M_PI) / 24;
outsideTemp = eq + amp * sin( per * timer);
slaapkamer.calcTemp(outsideTemp);
temp = slaapkamer.getTemp();
++timer;
delay(1000);
}
Code/libraries/Kamer/keywords.txt
+12
View File
@@ -0,0 +1,12 @@
Kamer KEYWORD1
setVolume KEYWORD2
setTemp KEYWORD2
setSurfaceArea KEYWORD2
calcTemp KEYWORD2
calcHeatFlow KEYWORD2
getVolume KEYWORD2
getTemp KEYWORD2
getSurfaceArea KEYWORD2
Code/libraries/Kamer/readme.txt
+39
View File
@@ -0,0 +1,39 @@
This is an example C++ library for Arduino 0004+, based on one created by
Nicholas Zambetti for Wiring 0006+
Installation
--------------------------------------------------------------------------------
To install this library, just place this entire folder as a subfolder in your
Arduino/lib/targets/libraries folder.
When installed, this library should look like:
Arduino/lib/targets/libraries/Test (this library's folder)
Arduino/lib/targets/libraries/Test/Test.cpp (the library implementation file)
Arduino/lib/targets/libraries/Test/Test.h (the library description file)
Arduino/lib/targets/libraries/Test/keywords.txt (the syntax coloring file)
Arduino/lib/targets/libraries/Test/examples (the examples in the "open" menu)
Arduino/lib/targets/libraries/Test/readme.txt (this file)
Building
--------------------------------------------------------------------------------
After this library is installed, you just have to start the Arduino application.
You may see a few warning messages as it's built.
To use this library in a sketch, go to the Sketch | Import Library menu and
select Test. This will add a corresponding line to the top of your sketch:
#include <Test.h>
To stop using this library, delete that line from your sketch.
Geeky information:
After a successful build of this library, a new file named "Test.o" will appear
in "Arduino/lib/targets/libraries/Test". This file is the built/compiled library
code.
If you choose to modify the code for this library (i.e. "Test.cpp" or "Test.h"),
then you must first 'unbuild' this library by deleting the "Test.o" file. The
new "Test.o" with your code will appear after the next press of "verify"
Code/libraries/LiquidCrystal_I2C/LiquidCrystal_I2C.cpp
+322
View File
@@ -0,0 +1,322 @@
//www.DFRobot.com
//last updated on 21/12/2011
//Tim Starling Fix the reset bug (Thanks Tim)
//wiki doc http://www.dfrobot.com/wiki/index.php?title=I2C/TWI_LCD1602_Module_(SKU:_DFR0063)
//Support Forum: http://www.dfrobot.com/forum/
//Compatible with the Arduino IDE 1.0
//Library version:1.1
#include "LiquidCrystal_I2C.h"
#include <inttypes.h>
#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h"
#define printIIC(args) Wire.write(args)
inline size_t LiquidCrystal_I2C::write(uint8_t value) {
send(value, Rs);
return 0;
}
#else
#include "WProgram.h"
#define printIIC(args) Wire.send(args)
inline void LiquidCrystal_I2C::write(uint8_t value) {
send(value, Rs);
}
#endif
#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).
LiquidCrystal_I2C::LiquidCrystal_I2C(uint8_t lcd_Addr,uint8_t lcd_cols,uint8_t lcd_rows)
{
_Addr = lcd_Addr;
_cols = lcd_cols;
_rows = lcd_rows;
_backlightval = LCD_NOBACKLIGHT;
}
void LiquidCrystal_I2C::init(){
init_priv();
}
void LiquidCrystal_I2C::init_priv()
{
Wire.begin();
_displayfunction = LCD_4BITMODE | LCD_1LINE | LCD_5x8DOTS;
begin(_cols, _rows);
}
void LiquidCrystal_I2C::begin(uint8_t cols, uint8_t lines, uint8_t dotsize) {
if (lines > 1) {
_displayfunction |= LCD_2LINE;
}
_numlines = lines;
// for some 1 line displays you can select a 10 pixel high font
if ((dotsize != 0) && (lines == 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 LiquidCrystal_I2C::clear(){
command(LCD_CLEARDISPLAY);// clear display, set cursor position to zero
delayMicroseconds(2000); // this command takes a long time!
}
void LiquidCrystal_I2C::home(){
command(LCD_RETURNHOME); // set cursor position to zero
delayMicroseconds(2000); // this command takes a long time!
}
void LiquidCrystal_I2C::setCursor(uint8_t col, uint8_t row){
int row_offsets[] = { 0x00, 0x40, 0x14, 0x54 };
if ( row > _numlines ) {
row = _numlines-1; // we count rows starting w/0
}
command(LCD_SETDDRAMADDR | (col + row_offsets[row]));
}
// Turn the display on/off (quickly)
void LiquidCrystal_I2C::noDisplay() {
_displaycontrol &= ~LCD_DISPLAYON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystal_I2C::display() {
_displaycontrol |= LCD_DISPLAYON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
// Turns the underline cursor on/off
void LiquidCrystal_I2C::noCursor() {
_displaycontrol &= ~LCD_CURSORON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystal_I2C::cursor() {
_displaycontrol |= LCD_CURSORON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
// Turn on and off the blinking cursor
void LiquidCrystal_I2C::noBlink() {
_displaycontrol &= ~LCD_BLINKON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystal_I2C::blink() {
_displaycontrol |= LCD_BLINKON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
// These commands scroll the display without changing the RAM
void LiquidCrystal_I2C::scrollDisplayLeft(void) {
command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVELEFT);
}
void LiquidCrystal_I2C::scrollDisplayRight(void) {
command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVERIGHT);
}
// This is for text that flows Left to Right
void LiquidCrystal_I2C::leftToRight(void) {
_displaymode |= LCD_ENTRYLEFT;
command(LCD_ENTRYMODESET | _displaymode);
}
// This is for text that flows Right to Left
void LiquidCrystal_I2C::rightToLeft(void) {
_displaymode &= ~LCD_ENTRYLEFT;
command(LCD_ENTRYMODESET | _displaymode);
}
// This will 'right justify' text from the cursor
void LiquidCrystal_I2C::autoscroll(void) {
_displaymode |= LCD_ENTRYSHIFTINCREMENT;
command(LCD_ENTRYMODESET | _displaymode);
}
// This will 'left justify' text from the cursor
void LiquidCrystal_I2C::noAutoscroll(void) {
_displaymode &= ~LCD_ENTRYSHIFTINCREMENT;
command(LCD_ENTRYMODESET | _displaymode);
}
// Allows us to fill the first 8 CGRAM locations
// with custom characters
void 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 LiquidCrystal_I2C::noBacklight(void) {
_backlightval=LCD_NOBACKLIGHT;
expanderWrite(0);
}
void LiquidCrystal_I2C::backlight(void) {
_backlightval=LCD_BACKLIGHT;
expanderWrite(0);
}
/*********** mid level commands, for sending data/cmds */
inline void LiquidCrystal_I2C::command(uint8_t value) {
send(value, 0);
}
/************ low level data pushing commands **********/
// write either command or data
void 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 LiquidCrystal_I2C::write4bits(uint8_t value) {
expanderWrite(value);
pulseEnable(value);
}
void LiquidCrystal_I2C::expanderWrite(uint8_t _data){
Wire.beginTransmission(_Addr);
printIIC((int)(_data) | _backlightval);
Wire.endTransmission();
}
void 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
}
// Alias functions
void LiquidCrystal_I2C::cursor_on(){
cursor();
}
void LiquidCrystal_I2C::cursor_off(){
noCursor();
}
void LiquidCrystal_I2C::blink_on(){
blink();
}
void LiquidCrystal_I2C::blink_off(){
noBlink();
}
void LiquidCrystal_I2C::load_custom_character(uint8_t char_num, uint8_t *rows){
createChar(char_num, rows);
}
void LiquidCrystal_I2C::setBacklight(uint8_t new_val){
if(new_val){
backlight(); // turn backlight on
}else{
noBacklight(); // turn backlight off
}
}
void 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);
}
// unsupported API functions
void LiquidCrystal_I2C::off(){}
void LiquidCrystal_I2C::on(){}
void LiquidCrystal_I2C::setDelay (int cmdDelay,int charDelay) {}
uint8_t LiquidCrystal_I2C::status(){return 0;}
uint8_t LiquidCrystal_I2C::keypad (){return 0;}
uint8_t LiquidCrystal_I2C::init_bargraph(uint8_t graphtype){return 0;}
void LiquidCrystal_I2C::draw_horizontal_graph(uint8_t row, uint8_t column, uint8_t len, uint8_t pixel_col_end){}
void LiquidCrystal_I2C::draw_vertical_graph(uint8_t row, uint8_t column, uint8_t len, uint8_t pixel_row_end){}
void LiquidCrystal_I2C::setContrast(uint8_t new_val){}
Code/libraries/LiquidCrystal_I2C/LiquidCrystal_I2C.h
+126
View File
@@ -0,0 +1,126 @@
//DFRobot.com
#ifndef LiquidCrystal_I2C_h
#define LiquidCrystal_I2C_h
#include <inttypes.h>
#include "Print.h"
#include <Wire.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
class LiquidCrystal_I2C : public Print {
public:
LiquidCrystal_I2C(uint8_t lcd_Addr,uint8_t lcd_cols,uint8_t lcd_rows);
void begin(uint8_t cols, uint8_t rows, uint8_t charsize = LCD_5x8DOTS );
void clear();
void home();
void noDisplay();
void display();
void noBlink();
void blink();
void noCursor();
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);
#if defined(ARDUINO) && ARDUINO >= 100
virtual size_t write(uint8_t);
#else
virtual void write(uint8_t);
#endif
void command(uint8_t);
void init();
////compatibility API function aliases
void blink_on(); // alias for blink()
void blink_off(); // alias for noBlink()
void cursor_on(); // alias for cursor()
void cursor_off(); // alias for noCursor()
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[]);
////Unsupported API functions (not implemented in this library)
uint8_t status();
void setContrast(uint8_t new_val);
uint8_t keypad();
void setDelay(int,int);
void on();
void off();
uint8_t init_bargraph(uint8_t graphtype);
void draw_horizontal_graph(uint8_t row, uint8_t column, uint8_t len, uint8_t pixel_col_end);
void draw_vertical_graph(uint8_t row, uint8_t column, uint8_t len, uint8_t pixel_col_end);
private:
void init_priv();
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 _numlines;
uint8_t _cols;
uint8_t _rows;
uint8_t _backlightval;
};
#endif
Code/libraries/LiquidCrystal_I2C/LiquidCrystal_I2C.o
BIN
View File
Binary file not shown.
Code/libraries/LiquidCrystal_I2C/diff.txt
+69
View File
@@ -0,0 +1,69 @@
1,6c1
< //www.DFRobot.com
< //last updated on 26/11/2010
< //Tim Starling Fix the reset bug (Thanks Tim)
< //wiki doc http://www.dfrobot.com/wiki/index.php?title=I2C/TWI_LCD1602_Module_(SKU:_DFR0063)
< //Support Forum: http://www.dfrobot.com/forum/
<
---
> // LiquidCrystal_I2C V2.0
10d4
< #include "WProgram.h"
12c6
<
---
> #include "Arduino.h"
67c61
< delay(50);
---
> delayMicroseconds(50000);
77,90c71,84
< // 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);
---
> // we start in 8bit mode, try to set 4 bit mode
> write4bits(0x03);
> delayMicroseconds(4500); // wait min 4.1ms
>
> // second try
> write4bits(0x03);
> delayMicroseconds(4500); // wait min 4.1ms
>
> // third go!
> write4bits(0x03);
> delayMicroseconds(150);
>
> // finally, set to 4-bit interface
> write4bits(0x02);
225c219
< inline void LiquidCrystal_I2C::write(uint8_t value) {
---
> inline size_t LiquidCrystal_I2C::write(uint8_t value) {
226a221
> return 0;
235,238c230,233
< uint8_t highnib=value&0xf0;
< uint8_t lownib=(value<<4)&0xf0;
< write4bits((highnib)|mode);
< write4bits((lownib)|mode);
---
> uint8_t highnib=value>>4;
> uint8_t lownib=value & 0x0F;
> write4bits((highnib)|mode);
> write4bits((lownib)|mode);
248c243
< Wire.send((int)(_data) | _backlightval);
---
> Wire.write((int)(_data) | _backlightval);
Code/libraries/LiquidCrystal_I2C/examples/CustomChars/CustomChars.pde
+70
View File
@@ -0,0 +1,70 @@
//DFRobot.com
//Compatible with the Arduino IDE 1.0
//Library version:1.1
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#if defined(ARDUINO) && ARDUINO >= 100
#define printByte(args) write(args);
#else
#define printByte(args) print(args,BYTE);
#endif
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};
LiquidCrystal_I2C lcd(0x3f,16,2); // set the LCD address to 0x3f for a 16 chars and 2 line display
void setup()
{
lcd.init(); // initialize the lcd
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.printByte(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.printByte(i+j);
}
i+=16;
delay(4000);
}
}
void loop()
{
}
Code/libraries/LiquidCrystal_I2C/examples/HelloWorld/HelloWorld.pde
+20
View File
@@ -0,0 +1,20 @@
//DFRobot.com
//Compatible with the Arduino IDE 1.0
//Library version:1.1
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x3f,16,2); // set the LCD address to 0x3f for a 16 chars and 2 line display
void setup()
{
lcd.init(); // initialize the lcd
// Print a message to the LCD.
lcd.backlight();
lcd.print("Hello, world!");
}
void loop()
{
}
Code/libraries/LiquidCrystal_I2C/examples/SerialDisplay/SerialDisplay.pde
+34
View File
@@ -0,0 +1,34 @@
/*
* Displays text sent over the serial port (e.g. from the Serial Monitor) on
* an attached LCD.
* DFRobot.com
*Compatible with the Arduino IDE 1.0
*Library version:1.1
*/
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x3f,16,2); // set the LCD address to 0x3f for a 16 chars and 2 line display
void setup()
{
lcd.init(); // initialize the lcd
lcd.backlight();
Serial.begin(9600);
}
void loop()
{
// when characters arrive over the serial port...
if (Serial.available()) {
// wait a bit for the entire message to arrive
delay(100);
// clear the screen
lcd.clear();
// read all the available characters
while (Serial.available() > 0) {
// display each character to the LCD
lcd.write(Serial.read());
}
}
}
Code/libraries/LiquidCrystal_I2C/keywords.txt
+46
View File
@@ -0,0 +1,46 @@
###########################################
# Syntax Coloring Map For LiquidCrystal_I2C
###########################################
###########################################
# Datatypes (KEYWORD1)
###########################################
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)
###########################################
Code/libraries/Mens/Mens.cpp
+61
View File
@@ -0,0 +1,61 @@
/*
Mens.cpp
Copyright (c) 2014 Kenneth van Ewijk. All right reserved.
*/
// include this library's description file
#include "Mens.h"
Mens::Mens(void)
{
// initialize this instance's variables
pattern[80][3];
counter = 0;
}
//Set Heater Properties
void Mens::setPattern(int givenPattern[80][3], int len)
{
pattern[80][3] = givenPattern[80][3];
}
int Mens::getTimeToEnter(int givenTime){
int timer = givenTime % 25200;
int enter = pattern[counter][0];
int room = pattern[counter][1];
int leave = pattern[counter][2];
if(timer > leave){
counter++;
}
int rtn[2] = {enter-timer, room};
if(rtn[0] < 0 && rtn[1]==0){
rtn[2] = getTimeToEnter(timer);
}
return rtn[2];
}
int Mens::getTimeToLeave(int givenTime){
int timer = givenTime % 25200;
int enter = pattern[counter][0];
int room = pattern[counter][1];
int leave = pattern[counter][2];
if(timer > leave){
counter++;
}
int rtn[2] = {leave-timer, room};
if(rtn[0] < 0 && rtn[1]==0){
rtn[2] = getTimeToEnter(timer);
}
return rtn[2];
}
Code/libraries/Mens/Mens.h
+24
View File
@@ -0,0 +1,24 @@
/*
Mens.h
Copyright (c) 2014 Kenneth van Ewijk. All right reserved.
*/
// ensure this library description is only included once
#ifndef Mens_h
#define Mens_h
// library interface description
class Mens
{
// user-accessible "public" interface
public:
Mens(void);
void setPattern(int[80][3], int);
int getTimeToEnter(int);
int getTimeToLeave(int);
private:
int pattern[80][3];
int counter;
};
#endif
Code/libraries/Mens/examples/usage/usage.pde
+22
View File
@@ -0,0 +1,22 @@
#include <Mens.h>
// Library for "Mens"
// by Kenneth van Ewijk <http://www.kennyboy.nl>
// Demostrates how to do something with the Mens library
// Created 5 April 2014
Mens kenneth = Mens();
void setup()
{
kenneth.setPattern({ {0,1,500}, {600,2,800}, {800,1,3600}, {3800,4,4000} });
}
void loop()
{
//Do stuff with a person
}
Code/libraries/Mens/keywords.txt
+5
View File
@@ -0,0 +1,5 @@
Mens KEYWORD1
setPattern KEYWORD2
setTimeToEnter KEYWORD2
setTimeToLeave KEYWORD2
Code/libraries/Mens/readme.txt
+39
View File
@@ -0,0 +1,39 @@
This is an example C++ library for Arduino 0004+, based on one created by
Nicholas Zambetti for Wiring 0006+
Installation
--------------------------------------------------------------------------------
To install this library, just place this entire folder as a subfolder in your
Arduino/lib/targets/libraries folder.
When installed, this library should look like:
Arduino/lib/targets/libraries/Test (this library's folder)
Arduino/lib/targets/libraries/Test/Test.cpp (the library implementation file)
Arduino/lib/targets/libraries/Test/Test.h (the library description file)
Arduino/lib/targets/libraries/Test/keywords.txt (the syntax coloring file)
Arduino/lib/targets/libraries/Test/examples (the examples in the "open" menu)
Arduino/lib/targets/libraries/Test/readme.txt (this file)
Building
--------------------------------------------------------------------------------
After this library is installed, you just have to start the Arduino application.
You may see a few warning messages as it's built.
To use this library in a sketch, go to the Sketch | Import Library menu and
select Test. This will add a corresponding line to the top of your sketch:
#include <Test.h>
To stop using this library, delete that line from your sketch.
Geeky information:
After a successful build of this library, a new file named "Test.o" will appear
in "Arduino/lib/targets/libraries/Test". This file is the built/compiled library
code.
If you choose to modify the code for this library (i.e. "Test.cpp" or "Test.h"),
then you must first 'unbuild' this library by deleting the "Test.o" file. The
new "Test.o" with your code will appear after the next press of "verify"
Code/libraries/Verwarming/Verwarming.cpp
+146
View File
@@ -0,0 +1,146 @@
/*
Verwarming.cpp
Copyright (c) 2014 Kenneth van Ewijk. All right reserved.
*/
// include this library's description file
#include "Verwarming.h"
#include "Arduino.h"
#include "Wire.h"
Verwarming::Verwarming(void)
{
// initialize this instance's variables
temp = 0;
wattage = 0;
state = false;
volume = 0;
led = 0;
}
//Set Heater Properties
void Verwarming::setTemp(double givenTemp)
{
temp = givenTemp;
}
void Verwarming::setState(bool givenState){
state = givenState;
}
void Verwarming::setWattage(int givenWattage){
wattage = givenWattage;
deltaTemp = (wattage / ( (volume * 1.293) * 1000) ) * 60;
}
void Verwarming::setVolume(int givenVolume){
volume = givenVolume;
deltaTemp = (wattage / ( (volume * 1.293) * 1000) ) * 60;
}
void Verwarming::setLed(int givenLed){
led = givenLed;
pinMode(led, OUTPUT);
}
//Calc Heater Properties
void Verwarming::toggleLed(void)
{
if(state){
analogWrite(led, 255);
}
else {
analogWrite(led, 0);
}
}
//Calc Heater Properties
double Verwarming::calcTemp(void)
{
if(state){
double newTemp = temp + deltaTemp;
return newTemp;
}
else {
return temp;
}
}
void Verwarming::keepTemp(double givenTemp)
{
if(temp >= givenTemp){
state = false;
}
else if(temp < givenTemp){
state = true;
}
toggleLed();
temp = calcTemp();
}
void Verwarming::gotoTemp(double givenTemp)
{
if(temp >= givenTemp){
state = false;
}
double newTemp = calcTemp();
if(newTemp <= givenTemp){
temp = newTemp;
}
else {
state = false;
}
toggleLed();
}
//Get Heater Properties
double Verwarming::getTemp(void)
{
return temp;
}
int Verwarming::getWattage(void)
{
return wattage;
}
bool Verwarming::getState(void){
return state;
}
double Verwarming::getDeltaTemp(void){
return deltaTemp;
}
int Verwarming::getTimeToTemp(double givenHeatFlow, double givenToTemp){
int timer = 0;
if(state){
double deltaTemp2 = givenToTemp - temp;
double neededHeat = (volume * 1.293) * 1000 * deltaTemp2;
double heatFlow = wattage - givenHeatFlow;
timer = neededHeat / heatFlow;
timer = timer / 60;
if(timer < 0){
timer = 0;
}
}
else{
timer = 0;
}
return timer;
}
Code/libraries/Verwarming/Verwarming.h
+42
View File
@@ -0,0 +1,42 @@
/*
Verwarming.h
Copyright (c) 2014 Kenneth van Ewijk. All right reserved.
*/
// ensure this library description is only included once
#ifndef Verwarming_h
#define Verwarming_h
#include "Print.h"
#include <Wire.h>
// library interface description
class Verwarming
{
// user-accessible "public" interface
public:
Verwarming(void);
void setTemp(double);
void setState(bool);
void setWattage(int);
void setVolume(int);
void setLed(int);
double calcTemp(void);
void keepTemp(double);
void gotoTemp(double);
double getTemp(void);
int getWattage(void);
bool getState(void);
double getDeltaTemp(void);
int getTimeToTemp(double, double);
private:
void toggleLed(void);
double temp;
int wattage;
int volume;
bool state;
double deltaTemp;
int led;
};
#endif
Code/libraries/Verwarming/examples/usage/usage.pde
+23
View File
@@ -0,0 +1,23 @@
#include <Verwarming.h>
// Library for "Verwarming"
// by Kenneth van Ewijk <http://www.kennyboy.nl>
// Demostrates how to do something with the Verwarming library
// Created 16 February 2014
Verwarming heater = Verwarming();
void setup()
{
heater.setTemp(20);
heater.setState(true);
}
void loop()
{
//Do stuff with heater
}
Code/libraries/Verwarming/keywords.txt
+18
View File
@@ -0,0 +1,18 @@
Verwarming KEYWORD1
setTemp KEYWORD2
setState KEYWORD2
setWattage KEYWORD2
setVolume KEYWORD2
setLed KEYWORD2
calcTemp KEYWORD2
toggleLed KEYWORD2
keepTemp KEYWORD2
gotoTemp KEYWORD2
getTemp KEYWORD2
getWattage KEYWORD2
getState KEYWORD2
getDeltaTemp KEYWORD2
getTimeToTemp KEYWORD2
Code/libraries/Verwarming/readme.txt
+39
View File
@@ -0,0 +1,39 @@
This is an example C++ library for Arduino 0004+, based on one created by
Nicholas Zambetti for Wiring 0006+
Installation
--------------------------------------------------------------------------------
To install this library, just place this entire folder as a subfolder in your
Arduino/lib/targets/libraries folder.
When installed, this library should look like:
Arduino/lib/targets/libraries/Test (this library's folder)
Arduino/lib/targets/libraries/Test/Test.cpp (the library implementation file)
Arduino/lib/targets/libraries/Test/Test.h (the library description file)
Arduino/lib/targets/libraries/Test/keywords.txt (the syntax coloring file)
Arduino/lib/targets/libraries/Test/examples (the examples in the "open" menu)
Arduino/lib/targets/libraries/Test/readme.txt (this file)
Building
--------------------------------------------------------------------------------
After this library is installed, you just have to start the Arduino application.
You may see a few warning messages as it's built.
To use this library in a sketch, go to the Sketch | Import Library menu and
select Test. This will add a corresponding line to the top of your sketch:
#include <Test.h>
To stop using this library, delete that line from your sketch.
Geeky information:
After a successful build of this library, a new file named "Test.o" will appear
in "Arduino/lib/targets/libraries/Test". This file is the built/compiled library
code.
If you choose to modify the code for this library (i.e. "Test.cpp" or "Test.h"),
then you must first 'unbuild' this library by deleting the "Test.o" file. The
new "Test.o" with your code will appear after the next press of "verify"
Code/libraries/Weer/Weer.cpp
+50
View File
@@ -0,0 +1,50 @@
/*
Weer.cpp
Copyright (c) 2014 Kenneth van Ewijk. All right reserved.
*/
// include this library's description file
#include "Weer.h"
#include <stdlib.h>
#include <math.h>
#define _USE_MATH_DEFINES
Weer::Weer(void)
{
// initialize this instance's variables
min = 0;
newdag = 0;
dag = 0;
rd = 0;
rd2 = 0;
amp = 0;
outsideTemp = 0;
eq = 0;
}
void Weer::setTemp(double givenTemp)
{
outsideTemp = givenTemp;
}
void Weer::calcTemp(int timer){
min = timer;
newdag = floor(min / 3600) + 1;
if(newdag > dag){
rd = ((double) rand() / (RAND_MAX));
rd2 = round(rd * 5);
dag = newdag;
eq = 9- ((1/6) * dag) + rd2;
amp = (rd * 9) + 3;
}
outsideTemp = eq + (amp * sin( ((2 * M_PI) / 3600) * (min - 900)) );
}
double Weer::getTemp(void)
{
return outsideTemp;
}
Code/libraries/Weer/Weer.h
+30
View File
@@ -0,0 +1,30 @@
/*
Weer.h
Copyright (c) 2014 Kenneth van Ewijk. All right reserved.
*/
// ensure this library description is only included once
#ifndef Weer_h
#define Weer_h
// library interface description
class Weer
{
// user-accessible "public" interface
public:
Weer(void);
void setTemp(double);
void calcTemp(int);
double getTemp(void);
private:
int min;
int newdag;
int dag;
double rd;
double rd2;
double amp;
double outsideTemp;
double eq;
};
#endif
Code/libraries/Weer/examples/usage/usage.pde
+24
View File
@@ -0,0 +1,24 @@
#include <Weer.h>
// Library for "Weer"
// by Kenneth van Ewijk <http://www.kennyboy.nl>
// Demostrates how to do something with the Weer library
// Created 16 February 2014
Weer weer = Weer();
int timer = 0;
int temp = 0;
void setup()
{
}
void loop()
{
temp = weer.getTemp(timer);
++timer;
}
Code/libraries/Weer/keywords.txt
+4
View File
@@ -0,0 +1,4 @@
Weer KEYWORD1
getTemp KEYWORD2
setTemp KEYWORD2
Code/libraries/Weer/readme.txt
+39
View File
@@ -0,0 +1,39 @@
This is an example C++ library for Arduino 0004+, based on one created by
Nicholas Zambetti for Wiring 0006+
Installation
--------------------------------------------------------------------------------
To install this library, just place this entire folder as a subfolder in your
Arduino/lib/targets/libraries folder.
When installed, this library should look like:
Arduino/lib/targets/libraries/Test (this library's folder)
Arduino/lib/targets/libraries/Test/Test.cpp (the library implementation file)
Arduino/lib/targets/libraries/Test/Test.h (the library description file)
Arduino/lib/targets/libraries/Test/keywords.txt (the syntax coloring file)
Arduino/lib/targets/libraries/Test/examples (the examples in the "open" menu)
Arduino/lib/targets/libraries/Test/readme.txt (this file)
Building
--------------------------------------------------------------------------------
After this library is installed, you just have to start the Arduino application.
You may see a few warning messages as it's built.
To use this library in a sketch, go to the Sketch | Import Library menu and
select Test. This will add a corresponding line to the top of your sketch:
#include <Test.h>
To stop using this library, delete that line from your sketch.
Geeky information:
After a successful build of this library, a new file named "Test.o" will appear
in "Arduino/lib/targets/libraries/Test". This file is the built/compiled library
code.
If you choose to modify the code for this library (i.e. "Test.cpp" or "Test.h"),
then you must first 'unbuild' this library by deleting the "Test.o" file. The
new "Test.o" with your code will appear after the next press of "verify"
Logboek.xlsx
BIN
View File
Binary file not shown.
Profielwerkstuk.docx
BIN
View File
Binary file not shown.