Dieses Testat ist eine Aufgabe, indem Sie mit Ihren Smart Home eine Aufgabenstellung lösen müssen. Es werden folgende Punkte bewertet
Sie sind ein Entwickler für die Smart Home Systeme. Der Kunde hat ein Türsystem mit einem Schrittmotor und ein RFID System als Kontrollsystem. Wenn der RFID Tag richtig erkannt wird, wird die Tür geöffnet und bei einer Betätigung vom Button eins wird die Tür wieder geöffnet.
Init
Das System startet im Initialzustand. Hier wird die Grundinitialisierung durchgeführt, also alles hochfahren, prüfen, bereitmachen. Ohne Init läuft bekanntlich nichts, nicht mal Chaos.
Chip Abfrage
Nach der Initialisierung geht das System in den Zustand Chip Abfrage.
In diesem Zustand wartet das System darauf, dass ein RFID-Chip bzw. eine Karte präsentiert wird.
Lesen ID RFID Tag
Wird ein Chip erkannt, liest das System die ID des RFID-Tags aus.
Anschließend erfolgt eine Entscheidung:
ID ≠ zulässig: Die ID ist ungültig. Das System springt zurück zur Chip Abfrage und wartet erneut auf einen Chip.
ID = zulässig: Die ID ist korrekt und der Zugang wird erlaubt.
Tür öffnen
Bei gültiger ID wechselt das System in den Zustand Tür öffnen.
Der Türöffner wird angesteuert und die Tür wird freigegeben.
Tür schließen
Nach dem Öffnen geht das System in den Zustand Tür schließen.
Dieser Zustand wird ausgelöst, wenn der Button gedrückt wird (oder ein entsprechendes Signal kommt). Die Tür wird wieder geschlossen.
Rücksprung zur Chip Abfrage
Nach dem Schließen der Tür kehrt das System zurück zur Chip Abfrage und ist wieder bereit für den nächsten RFID-Chip.
![[{47AF5873-CDFB-4AF9-8919-9D98DDCB8007}.png]]
Die Erweiterung sollen die Themen der Sichtbarkeit der Zustände und Sicherheit des Smart Homes, Als erstes wird das System mit dem CO 2 Sensor und DHT11 erweitert.. Ebenfalls wird das System mit einem Display und LED erweitert.
Das System zeigt beim Hochfahren mit dem Text, „Guten Tag." im Display an. Anschließend wird in dem Display die Temperatur und den Zustand vom RFID abgefragt. Hier gibt es 4 Zustände, Warten, Katte gelesen, Tag Akzeptiert und Tag Abgelehnt. Jeder dieser Zustände werden in dem Display angezeigt. Bei dreimaligen fehlerhaften Abfrage, blinkt die LED für 5 Sekunden mit 2Hz. Bei richtiger Abfrage des Tags, öffnet sich die Tür und schließt bei den Tastendruck von Button 1 die Tür direkt. Sollte der CO2 Sensor aktiv werden, kann die Tür mit Button 1 geschlossen und mit Button 2 geöffnet werden. Die Zeichen CO2" werden auf dem Display angezeigt.
Initialisierung Projekt Für die Testat werden alle Supportdatei hochgeladen und die Datei Testat" ausgeführt. Sie erhalten 2 Tags Pro Gruppe. Den ersten Tag halten Sie gegen und notieren die Tag ID im folgenden Abschnitt. Dieser Tag ist ihre Ziel ID, Nun lesen Sie die Zweite ID ein. Diese Tragen Sie auch unten in der Liste ein. Diese ist ihre nicht Ziel ID.
| 1. Tag (Ziel ID) | |
|---|---|
| 2. Tag (Nicht Ziel ID) |
| Testszenario | Erledigt Ja / Nein? |
|---|---|
| Controller fährt fehlerfrei hoch | |
| Controller fährt initial hoch und zeigt im Text „Guten Tag“ auf dem Display | |
| Bei unbestätigtem (also überprüfen) Controller zeigt den RFID Zustand und die Temperatur | |
| Bei Betätigung des CO2 Sensors wird auf dem Display CO2 angezeigt und beim Löschen verschwindet der Aufdruck wieder | |
| Bei Betätigung des CO2 Sensors lässt die Tür sich mit Button 2 öffnen und mit Button 1 schließen. Mit Erlöschen des Zustands ist diese Funktion nicht mehr aktiv | |
| Temperatur verändert sich bei aktivem Integrieren mit dem Sensor (Testkriterium: Finger auf den Sensor um Temperatur zu verändern) | |
| Wenn eine Karte angehalten wird, wird für eine Sekunde „Karte da“ angezeigt | |
| Wenn die falsche Karte angezeigt wird, wird diese am Display für eine Sekunde angezeigt (falsche ID) | |
| Wenn die Karte drei mal falsch angehalten wird, blinkt die LED für 5 Sekunden mit 2 Hz | |
| Wenn die richtige Karte angehalten wird, öffnet sich die Tür und schließt sich mit Button 1. Auf dem Display wird „richtige ID“ angezeigt |
| Nr. | Gerät/Funktion | Bibliotheken / Imports | Initialisierung | Nutzungsfunktion |
|---|---|---|---|---|
| 1 | CO2 Sensor (Digital Input) | from machine import Pin | co2 = Pin(23, Pin.IN, Pin.PULL_UP) |
co2.value() |
| 2 | Bewegungssensor Sensor (Digital Input) | from machine import Pin | pir = Pin(14, Pin.IN, Pin.PULL_UP) |
pir.value() |
| 3 | Regensensor (Analog Input) | from machine import ADC, Pin | regen = ADC(Pin(34)) |
regen.read() |
| 4 | LCD Display I2C | from machine import I2C, Pin; from i2c_lcd import I2cLcd | i2c = I2C(0, scl=Pin(22), sda=Pin(21), freq=400000)``lcd = I2cLcd(i2c, 0x27, 2, 16) |
lcd.putstr()``lcd.move_to(zeile, spalte) |
| 5 | Button 1 (Digital Input) | from machine import Pin | btn1 = Pin(16, Pin.IN, Pin.PULL_UP) |
btn1.value() |
| 6 | Button 2 (Digital Input) | from machine import Pin | btn2 = Pin(27, Pin.IN, Pin.PULL_UP) |
btn2.value() |
| 7 | DHT11 Sensor (OneWire) | import dht, from machine import Pin | sensor = dht.DHT11(Pin(17)) |
sensor.measure()``sensor.temperature()``sensor.humidity() |
| 8 | LED (Digital Output) | from machine import Pin | led = Pin(12, Pin.OUT) |
led.value(1/0) |
| 9 | Ventilator (PWM) | from machine import Pin, PWM | Ven_c = PWM(Pin(PIN_18)); Ven_c.freq(1000) |
Ven_c.duty(0-1023) |
| 10 | Fenster (PWM) | from machine import Pin, PWM | fenster = PWM(Pin(5)); fenster.freq(50) |
fenster.duty(25) zufenster.duty(125) auf |
| 11 | Tür (PWM) | from machine import Pin, PWM | tuer = PWM(Pin(13)); tuer.freq(50) |
tuer.duty(25) zutuer.duty(125) auf |
| 12 | PWM Ausgang | from machine import Pin, PWM | pwm = PWM(Pin(PIN_NR)); pwm.freq(1000) |
pwm.duty(0-1023) |
| 13 | Sleep Funktion | import time | keine Initialisierung notwendig | time.sleep()``time.sleep_ms() |
| 14 | formatierter String | – | – | test_str = f"text {variable}" |
| 15 | Dauerschleife | – | – | while True: |
| 16 | Verknüpfung | – | – | if Bedingung:``elif Bedingung:``else: |
| 17 | for Schleife | – | – | for i in range(startwert, Endwert, Intervall) |
from machine import Pin, PWM,I2C, Pin
import time
from mfrc522_i2c import mfrc522
pwm = PWM(Pin(13))
pwm.freq(50)
button1 = Pin(16, Pin.IN, Pin.PULL_UP)
#i2c config
addr = 0x28
scl = 22
sda = 21
rc522 = mfrc522(scl, sda, addr)
rc522.PCD_Init()
rc522.ShowReaderDetails() # Show details of PCD - MFRC522 Card Reader details
data = 0
while True:
if rc522.PICC_IsNewCardPresent():
#print("Is new card present!")
if rc522.PICC_ReadCardSerial() == True:
print("Card UID:")
#print(rc522.uid.uidByte[0 : rc522.uid.size])
for i in rc522.uid.uidByte[0 : rc522.uid.size]:
data = data + i
print(data)
if(data == 656):
pwm.duty(128)
print("open")
else:
print("error")
data = 0
btnVal1 = button1.value()
if(btnVal1 == 0):
pwm.duty(25)
print("close")
time.sleep(1)
"""Implements a HD44780 character LCD connected via PCF8574 on I2C.
This was tested with: https://www.wemos.cc/product/d1-mini.html"""
from lcd_api import LcdApi
from machine import I2C
from time import sleep_ms
# The PCF8574 has a jumper selectable address: 0x20 - 0x27
#DEFAULT_I2C_ADDR = 0x20
# Defines shifts or masks for the various LCD line attached to the PCF8574
MASK_RS = 0x01
MASK_RW = 0x02
MASK_E = 0x04
SHIFT_BACKLIGHT = 3
SHIFT_DATA = 4
class I2cLcd(LcdApi):
"""Implements a HD44780 character LCD connected via PCF8574 on I2C."""
def __init__(self, i2c, i2c_addr, num_lines, num_columns):
self.i2c = i2c
self.i2c_addr = i2c_addr
self.i2c.writeto(self.i2c_addr, bytearray([0]))
sleep_ms(20) # Allow LCD time to powerup
# Send reset 3 times
self.hal_write_init_nibble(self.LCD_FUNCTION_RESET)
sleep_ms(5) # need to delay at least 4.1 msec
self.hal_write_init_nibble(self.LCD_FUNCTION_RESET)
sleep_ms(1)
self.hal_write_init_nibble(self.LCD_FUNCTION_RESET)
sleep_ms(1)
# Put LCD into 4 bit mode
self.hal_write_init_nibble(self.LCD_FUNCTION)
sleep_ms(1)
LcdApi.__init__(self, num_lines, num_columns)
cmd = self.LCD_FUNCTION
if num_lines > 1:
cmd |= self.LCD_FUNCTION_2LINES
self.hal_write_command(cmd)
def hal_write_init_nibble(self, nibble):
"""Writes an initialization nibble to the LCD.
This particular function is only used during initialization.
"""
byte = ((nibble >> 4) & 0x0f) << SHIFT_DATA
self.i2c.writeto(self.i2c_addr, bytearray([byte | MASK_E]))
self.i2c.writeto(self.i2c_addr, bytearray([byte]))
def hal_backlight_on(self):
"""Allows the hal layer to turn the backlight on."""
self.i2c.writeto(self.i2c_addr, bytearray([1 << SHIFT_BACKLIGHT]))
def hal_backlight_off(self):
"""Allows the hal layer to turn the backlight off."""
self.i2c.writeto(self.i2c_addr, bytearray([0]))
def hal_write_command(self, cmd):
"""Writes a command to the LCD.
Data is latched on the falling edge of E.
"""
byte = ((self.backlight << SHIFT_BACKLIGHT) | (((cmd >> 4) & 0x0f) << SHIFT_DATA))
self.i2c.writeto(self.i2c_addr, bytearray([byte | MASK_E]))
self.i2c.writeto(self.i2c_addr, bytearray([byte]))
byte = ((self.backlight << SHIFT_BACKLIGHT) | ((cmd & 0x0f) << SHIFT_DATA))
self.i2c.writeto(self.i2c_addr, bytearray([byte | MASK_E]))
self.i2c.writeto(self.i2c_addr, bytearray([byte]))
if cmd <= 3:
# The home and clear commands require a worst case delay of 4.1 msec
sleep_ms(5)
def hal_write_data(self, data):
"""Write data to the LCD."""
byte = (MASK_RS | (self.backlight << SHIFT_BACKLIGHT) | (((data >> 4) & 0x0f) << SHIFT_DATA))
self.i2c.writeto(self.i2c_addr, bytearray([byte | MASK_E]))
self.i2c.writeto(self.i2c_addr, bytearray([byte]))
byte = (MASK_RS | (self.backlight << SHIFT_BACKLIGHT) | ((data & 0x0f) << SHIFT_DATA))
self.i2c.writeto(self.i2c_addr, bytearray([byte | MASK_E]))
self.i2c.writeto(self.i2c_addr, bytearray([byte]))
"""Provides an API for talking to HD44780 compatible character LCDs."""
import time
class LcdApi:
"""Implements the API for talking with HD44780 compatible character LCDs.
This class only knows what commands to send to the LCD, and not how to get
them to the LCD.
It is expected that a derived class will implement the hal_xxx functions.
"""
# The following constant names were lifted from the avrlib lcd.h
# header file, however, I changed the definitions from bit numbers
# to bit masks.
#
# HD44780 LCD controller command set
LCD_CLR = 0x01 # DB0: clear display
LCD_HOME = 0x02 # DB1: return to home position
LCD_ENTRY_MODE = 0x04 # DB2: set entry mode
LCD_ENTRY_INC = 0x02 # --DB1: increment
LCD_ENTRY_SHIFT = 0x01 # --DB0: shift
LCD_ON_CTRL = 0x08 # DB3: turn lcd/cursor on
LCD_ON_DISPLAY = 0x04 # --DB2: turn display on
LCD_ON_CURSOR = 0x02 # --DB1: turn cursor on
LCD_ON_BLINK = 0x01 # --DB0: blinking cursor
LCD_MOVE = 0x10 # DB4: move cursor/display
LCD_MOVE_DISP = 0x08 # --DB3: move display (0-> move cursor)
LCD_MOVE_RIGHT = 0x04 # --DB2: move right (0-> left)
LCD_FUNCTION = 0x20 # DB5: function set
LCD_FUNCTION_8BIT = 0x10 # --DB4: set 8BIT mode (0->4BIT mode)
LCD_FUNCTION_2LINES = 0x08 # --DB3: two lines (0->one line)
LCD_FUNCTION_10DOTS = 0x04 # --DB2: 5x10 font (0->5x7 font)
LCD_FUNCTION_RESET = 0x30 # See "Initializing by Instruction" section
LCD_CGRAM = 0x40 # DB6: set CG RAM address
LCD_DDRAM = 0x80 # DB7: set DD RAM address
LCD_RS_CMD = 0
LCD_RS_DATA = 1
LCD_RW_WRITE = 0
LCD_RW_READ = 1
def __init__(self, num_lines, num_columns):
self.num_lines = num_lines
if self.num_lines > 4:
self.num_lines = 4
self.num_columns = num_columns
if self.num_columns > 40:
self.num_columns = 40
self.cursor_x = 0
self.cursor_y = 0
self.implied_newline = False
self.backlight = True
self.display_off()
self.backlight_on()
self.clear()
self.hal_write_command(self.LCD_ENTRY_MODE | self.LCD_ENTRY_INC)
self.hide_cursor()
self.display_on()
def clear(self):
"""Clears the LCD display and moves the cursor to the top left
corner.
"""
self.hal_write_command(self.LCD_CLR)
self.hal_write_command(self.LCD_HOME)
self.cursor_x = 0
self.cursor_y = 0
def show_cursor(self):
"""Causes the cursor to be made visible."""
self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY |
self.LCD_ON_CURSOR)
def hide_cursor(self):
"""Causes the cursor to be hidden."""
self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY)
def blink_cursor_on(self):
"""Turns on the cursor, and makes it blink."""
self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY |
self.LCD_ON_CURSOR | self.LCD_ON_BLINK)
def blink_cursor_off(self):
"""Turns on the cursor, and makes it no blink (i.e. be solid)."""
self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY |
self.LCD_ON_CURSOR)
def display_on(self):
"""Turns on (i.e. unblanks) the LCD."""
self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY)
def display_off(self):
"""Turns off (i.e. blanks) the LCD."""
self.hal_write_command(self.LCD_ON_CTRL)
def backlight_on(self):
"""Turns the backlight on.
This isn't really an LCD command, but some modules have backlight
controls, so this allows the hal to pass through the command.
"""
self.backlight = True
self.hal_backlight_on()
def backlight_off(self):
"""Turns the backlight off.
This isn't really an LCD command, but some modules have backlight
controls, so this allows the hal to pass through the command.
"""
self.backlight = False
self.hal_backlight_off()
def move_to(self, cursor_x, cursor_y):
"""Moves the cursor position to the indicated position. The cursor
position is zero based (i.e. cursor_x == 0 indicates first column).
"""
self.cursor_x = cursor_x
self.cursor_y = cursor_y
addr = cursor_x & 0x3f
if cursor_y & 1:
addr += 0x40 # Lines 1 & 3 add 0x40
if cursor_y & 2: # Lines 2 & 3 add number of columns
addr += self.num_columns
self.hal_write_command(self.LCD_DDRAM | addr)
def putchar(self, char):
"""Writes the indicated character to the LCD at the current cursor
position, and advances the cursor by one position.
"""
if char == '\n':
if self.implied_newline:
# self.implied_newline means we advanced due to a wraparound,
# so if we get a newline right after that we ignore it.
pass
else:
self.cursor_x = self.num_columns
else:
self.hal_write_data(ord(char))
self.cursor_x += 1
if self.cursor_x >= self.num_columns:
self.cursor_x = 0
self.cursor_y += 1
self.implied_newline = (char != '\n')
if self.cursor_y >= self.num_lines:
self.cursor_y = 0
self.move_to(self.cursor_x, self.cursor_y)
def putstr(self, string):
"""Write the indicated string to the LCD at the current cursor
position and advances the cursor position appropriately.
"""
for char in string:
self.putchar(char)
def custom_char(self, location, charmap):
"""Write a character to one of the 8 CGRAM locations, available
as chr(0) through chr(7).
"""
location &= 0x7
self.hal_write_command(self.LCD_CGRAM | (location << 3))
self.hal_sleep_us(40)
for i in range(8):
self.hal_write_data(charmap[i])
self.hal_sleep_us(40)
self.move_to(self.cursor_x, self.cursor_y)
def hal_backlight_on(self):
"""Allows the hal layer to turn the backlight on.
If desired, a derived HAL class will implement this function.
"""
pass
def hal_backlight_off(self):
"""Allows the hal layer to turn the backlight off.
If desired, a derived HAL class will implement this function.
"""
pass
def hal_write_command(self, cmd):
"""Write a command to the LCD.
It is expected that a derived HAL class will implement this
function.
"""
raise NotImplementedError
def hal_write_data(self, data):
"""Write data to the LCD.
It is expected that a derived HAL class will implement this
function.
"""
raise NotImplementedError
def hal_sleep_us(self, usecs):
"""Sleep for some time (given in microseconds)."""
time.sleep_us(usecs)