Temelelektronik.info

Çevrim Dışı Okul Çay Sayacı Devresi-RFID,Micropython,ESP8266

Devre


Bu devre Eylül ayından itibaren 137  defa ziyaret edilmiştir.

Video



Projenin Anlatımı: https://www.youtube.com/watch?v=Q7MzRVHWUbI&list=PLCd01BkUOM2fJZ_JE1z1r34nZrdCvBYu0&index=1

Açıklama

##__main.py__________________
import mfrc522
from os import uname
import time
from time import sleep

str2=''

from machine import Pin
buzzer=Pin(13,Pin.OUT)

#__Kullanici var mi kontrol et_______
def usercontrol(kartid):
    file=open("usr.txt","r")
    for f in file:
        if f.count(kartid)>0:
            print('kayitli kullanici')
            return True
            break       
    return False
    
##___tum kayitlari yazdir_________
def yazdir():
    file1 = open("cay.txt","r")
    for line in file1:
        print(line,end='')
    file1.close()

#_____uyari tonu cal_Normal
def ot():
    buzzer.value(1)
    time.sleep(0.1)
    buzzer.value(0)
    
#_____titrek uyari tonu cal__Hata
def titrekot():
    i=10
    while i>0:
        i=i-1
        buzzer.value(1)
        time.sleep(0.02)
        buzzer.value(0)
        time.sleep(0.02)

#___kac kayit var_______
def kayitsayisi(usrid):    
    f=open('cay.txt','r')
    cnt=0
    for line in f:   
        if line.count(usrid)>0:
            cnt=cnt+1
    print(cnt)
    f.close()
    return(cnt)

#____kaydı dosyaya ekle_______
def tofile(data):
    text_file = open("cay.txt", "a")
    n = text_file.write(data+'\n')
    print('{} karakter dosyaya eklendi'.format(n))
    text_file.close()
    return(kayitsayisi(data))
    
#____RFID kart oku__________
def do_read():

    if uname()[0] == 'WiPy':
        rdr = mfrc522.MFRC522("GP14", "GP16", "GP15", "GP22", "GP17")
    elif uname()[0] == 'esp8266':
        rdr = mfrc522.MFRC522(0, 2, 4, 5, 14)
    else:
        raise RuntimeError("Unsupported platform")

    print("")
    print("Place card before reader to read from address 0x08")
    print("")

    try:
        while True:

            (stat, tag_type) = rdr.request(rdr.REQIDL)

            if stat == rdr.OK:

                (stat, raw_uid) = rdr.anticoll()

                if stat == rdr.OK:
                    print("New card detected")
                    print("  - tag type: 0x%02x" % tag_type)
                    print("  - uid   : 0x%02x%02x%02x%02x" % (raw_uid[0], raw_uid[1], raw_uid[2], raw_uid[3]))
                    print("")
                    str2=str(raw_uid[0])+str(raw_uid[1])+str(raw_uid[2])+str(raw_uid[3])+str(raw_uid[4])
                    return(str2)
                    if rdr.select_tag(raw_uid) == rdr.OK:

                        key = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]

                        if rdr.auth(rdr.AUTHENT1A, 8, key, raw_uid) == rdr.OK:
                            print("Address 8 data: %s" % rdr.read(8))
                            rdr.stop_crypto1()
                        else:
                            print("Authentication error")
                    else:
                        print("Failed to select tag")

    except KeyboardInterrupt:
        print("Bye")

#_____Ana Program__________
while True:
    msg=do_read()
    if usercontrol(msg):
        ot()
        print(msg)
        print('Kullanicinin kayit sayisi:{}'.format(tofile(msg)))
        sleep(0.6)
    else:
        print('boyle bir kullanici yok')
        titrekot()
        sleep(0.3)



#mfrc522.py_______________
from machine import Pin, SPI
from os import uname


class MFRC522:

         OK = 0
         NOTAGERR = 1
         ERR = 2

         REQIDL = 0x26
         REQALL = 0x52
         AUTHENT1A = 0x60
         AUTHENT1B = 0x61

         def __init__(self, sck, mosi, miso, rst, cs):
                  self.sck = Pin(sck, Pin.OUT)
                  self.mosi = Pin(mosi, Pin.OUT)
                  self.miso = Pin(miso)
                  self.rst = Pin(rst, Pin.OUT)
                  self.cs = Pin(cs, Pin.OUT)

                  self.rst.value(0)
                  self.cs.value(1)
                  
                  board = uname()[0]

                  if board == 'WiPy' or board == 'LoPy' or board == 'FiPy':
                           self.spi = SPI(0)
                           self.spi.init(SPI.MASTER, baudrate=1000000, pins=(self.sck, self.mosi, self.miso))
                  elif board == 'esp8266':
                           self.spi = SPI(baudrate=100000, polarity=0, phase=0, sck=self.sck, mosi=self.mosi, miso=self.miso)
                           self.spi.init()
                  else:
                           raise RuntimeError("Unsupported platform")

                  self.rst.value(1)
                  self.init()

         def _wreg(self, reg, val):

                  self.cs.value(0)
                  self.spi.write(b'%c' % int(0xff & ((reg << 1) & 0x7e)))
                  self.spi.write(b'%c' % int(0xff & val))
                  self.cs.value(1)

         def _rreg(self, reg):

                  self.cs.value(0)
                  self.spi.write(b'%c' % int(0xff & (((reg << 1) & 0x7e) | 0x80)))
                  val = self.spi.read(1)
                  self.cs.value(1)

                  return val[0]

         def _sflags(self, reg, mask):
                  self._wreg(reg, self._rreg(reg) | mask)

         def _cflags(self, reg, mask):
                  self._wreg(reg, self._rreg(reg) & (~mask))

         def _tocard(self, cmd, send):

                  recv = []
                  bits = irq_en = wait_irq = n = 0
                  stat = self.ERR

                  if cmd == 0x0E:
                           irq_en = 0x12
                           wait_irq = 0x10
                  elif cmd == 0x0C:
                           irq_en = 0x77
                           wait_irq = 0x30

                  self._wreg(0x02, irq_en | 0x80)
                  self._cflags(0x04, 0x80)
                  self._sflags(0x0A, 0x80)
                  self._wreg(0x01, 0x00)

                  for c in send:
                           self._wreg(0x09, c)
                  self._wreg(0x01, cmd)

                  if cmd == 0x0C:
                           self._sflags(0x0D, 0x80)

                  i = 2000
                  while True:
                           n = self._rreg(0x04)
                           i -= 1
                           if ~((i != 0) and ~(n & 0x01) and ~(n & wait_irq)):
                                    break

                  self._cflags(0x0D, 0x80)

                  if i:
                           if (self._rreg(0x06) & 0x1B) == 0x00:
                                    stat = self.OK

                                    if n & irq_en & 0x01:
                                             stat = self.NOTAGERR
                                    elif cmd == 0x0C:
                                             n = self._rreg(0x0A)
                                             lbits = self._rreg(0x0C) & 0x07
                                             if lbits != 0:
                                                      bits = (n - 1) * 8 + lbits
                                             else:
                                                      bits = n * 8

                                             if n == 0:
                                                      n = 1
                                             elif n > 16:
                                                      n = 16

                                             for _ in range(n):
                                                      recv.append(self._rreg(0x09))
                           else:
                                    stat = self.ERR

                  return stat, recv, bits

         def _crc(self, data):

                  self._cflags(0x05, 0x04)
                  self._sflags(0x0A, 0x80)

                  for c in data:
                           self._wreg(0x09, c)

                  self._wreg(0x01, 0x03)

                  i = 0xFF
                  while True:
                           n = self._rreg(0x05)
                           i -= 1
                           if not ((i != 0) and not (n & 0x04)):
                                    break

                  return [self._rreg(0x22), self._rreg(0x21)]

         def init(self):

                  self.reset()
                  self._wreg(0x2A, 0x8D)
                  self._wreg(0x2B, 0x3E)
                  self._wreg(0x2D, 30)
                  self._wreg(0x2C, 0)
                  self._wreg(0x15, 0x40)
                  self._wreg(0x11, 0x3D)
                  self.antenna_on()

         def reset(self):
                  self._wreg(0x01, 0x0F)

         def antenna_on(self, on=True):

                  if on and ~(self._rreg(0x14) & 0x03):
                           self._sflags(0x14, 0x03)
                  else:
                           self._cflags(0x14, 0x03)

         def request(self, mode):

                  self._wreg(0x0D, 0x07)
                  (stat, recv, bits) = self._tocard(0x0C, [mode])

                  if (stat != self.OK) | (bits != 0x10):
                           stat = self.ERR

                  return stat, bits

         def anticoll(self):

                  ser_chk = 0
                  ser = [0x93, 0x20]

                  self._wreg(0x0D, 0x00)
                  (stat, recv, bits) = self._tocard(0x0C, ser)

                  if stat == self.OK:
                           if len(recv) == 5:
                                    for i in range(4):
                                             ser_chk = ser_chk ^ recv[i]
                                    if ser_chk != recv[4]:
                                             stat = self.ERR
                           else:
                                    stat = self.ERR

                  return stat, recv

         def select_tag(self, ser):

                  buf = [0x93, 0x70] + ser[:5]
                  buf += self._crc(buf)
                  (stat, recv, bits) = self._tocard(0x0C, buf)
                  return self.OK if (stat == self.OK) and (bits == 0x18) else self.ERR

         def auth(self, mode, addr, sect, ser):
                  return self._tocard(0x0E, [mode, addr] + sect + ser[:4])[0]

         def stop_crypto1(self):
                  self._cflags(0x08, 0x08)

         def read(self, addr):

                  data = [0x30, addr]
                  data += self._crc(data)
                  (stat, recv, _) = self._tocard(0x0C, data)
                  return recv if stat == self.OK else None

         def write(self, addr, data):

                  buf = [0xA0, addr]
                  buf += self._crc(buf)
                  (stat, recv, bits) = self._tocard(0x0C, buf)

                  if not (stat == self.OK) or not (bits == 4) or not ((recv[0] & 0x0F) == 0x0A):
                           stat = self.ERR
                  else:
                           buf = []
                           for i in range(16):
                                    buf.append(data[i])
                           buf += self._crc(buf)
                           (stat, recv, bits) = self._tocard(0x0C, buf)
                           if not (stat == self.OK) or not (bits == 4) or not ((recv[0] & 0x0F) == 0x0A):
                                    stat = self.ERR

                  return stat

Download

offlinecaysayaci.rar