def esp_connect():
fm.register(board_info.WIFI_RX, fm.fpioa.UART2_TX)
fm.register(board_info.WIFI_TX, fm.fpioa.UART2_RX)
uart = machine.UART(machine.UART.UART2,
115200,
timeout=1000,
read_buf_len=4096)
try:
nic = network.ESP8285(uart)
nic.connect(SSID, SSID_PWD)
if (nic.isconnected):
print("ip:{}/{}".format(nic.ifconfig()[0], nic.ifconfig()[1]))
return True
else:
sleep(1) # retry
if (nic.isconnected):
print("ip:{}/{}".format(nic.ifconfig()[0], nic.ifconfig()[1]))
return True
else:
print("network connection failed.\n")
return False
except:
print(" try to connect ESP8286 TX to pin-{},RX to pin-{}".format(
board_info.WIFI_TX, board_info.WIFI_RX))
print(" ,and ESP8286 must be runing on AT command mode.\n")
return False
def init():
global wav_dev, spk_sd
lcd.init()
lcd.rotation(2)
# for wav
fm.register(board_info.SPK_SD, fm.fpioa.GPIO0)
spk_sd = GPIO(GPIO.GPIO0, GPIO.OUT)
spk_sd.value(1) #Enable the SPK output
fm.register(board_info.SPK_DIN, fm.fpioa.I2S0_OUT_D1)
fm.register(board_info.SPK_BCLK, fm.fpioa.I2S0_SCLK)
fm.register(board_info.SPK_LRCLK, fm.fpioa.I2S0_WS)
wav_dev = I2S(I2S.DEVICE_0)
# button
fm.register(board_info.BUTTON_A, fm.fpioa.GPIO1)
but_a = GPIO(GPIO.GPIO1, GPIO.IN, GPIO.PULL_UP)
if but_a.value() == 0:
sys.exit()
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.VGA)
sensor.run(1)
def bit_sensor(): #摄像头
print("开始测试摄像头...")
try:
lcd.draw_string(30, 50, 'Start test Camera (End by touch) ', lcd.RED,
lcd.BLACK)
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
sensor.run(1)
sensor.skip_frames()
except:
#break
lcd.draw_string(90, 120, 'Camera test failed! ', lcd.GREEN, lcd.BLACK)
print("摄像头初始化失败！")
i = 0
fm.register(9, fm.fpioa.GPIO1)
key_4 = GPIO(GPIO.GPIO1, GPIO.IN, GPIO.PULL_UP)
while (key_4.value() == 1):
lcd.display(sensor.snapshot())
i = i + 1
if i > 150:
break
lcd.draw_string(90, 90, 'End Camera test ', lcd.RED, lcd.BLACK)
time.sleep(1)
lcd.clear()
print("摄像头实时显示测试完成")
def __init__(self):
self.home_last = 1
self.cache = {
'home': 0,
}
fm.register(ttgo_button.PIR, fm.fpioa.GPIOHS16, force=True)
self.home_button = GPIO(GPIO.GPIOHS16, GPIO.IN, GPIO.PULL_UP)
def __init__(self):
try:
fm.register(board_info.WIFI_RX, fm.fpioa.UART2_TX)
fm.register(board_info.WIFI_TX, fm.fpioa.UART2_RX)
self.uart = UART(UART.UART2, 115200, 8, None, 1,
timeout=1000, read_buf_len=4096)
print("Init CORGI85")
except:
print("Unable to init UART")
def connect(self):
from fpioa_manager import fm
import machine
fm.register(35, fm.fpioa.UARTHS_RX, force=True)
fm.register(34, fm.fpioa.UARTHS_TX, force=True)
self.uart = machine.UART(machine.UART.UARTHS, 115200, 8, 0, 1, timeout=1000, read_buf_len=4096)
self.uart.init()
self.timer.start()
return self.uart
def run():
# debug into app_select
# launcher.app_select = 2
# app.layer = 1
ui.height, ui.weight = 480, 320
# button_io.config(23, 20, 31) # amigo tft
button_io.config(16, 23, 20) # amigo ips
sipeed_led.init(14, 15, 17, 32)
app.i2c3 = I2C(I2C.I2C3, freq=100 * 1000, scl=24, sda=27)
app.i2c4 = I2C(I2C.I2C4, freq=100 * 1000, scl=9, sda=7)
TouchLow.config(i2c3=app.i2c3) # amigo
#if AXP173_ADDR in i2c.scan():
axp173 = AXP173(i2c_dev=app.i2c3)
axp173.enable_adc(True)
# 默认充电限制在 4.2V, 190mA 档位
axp173.setEnterChargingControl(True)
axp173.exten_output_enable()
# amigo sensor config.
axp173.writeREG(0x27, 0x20)
axp173.writeREG(0x28, 0x0C)
taskbar.init(axp173)
CubeAudio.init(app.i2c3)
if CubeAudio.check():
CubeAudio.ready()
fm.register(13, fm.fpioa.I2S0_MCLK, force=True)
fm.register(21, fm.fpioa.I2S0_SCLK, force=True)
fm.register(18, fm.fpioa.I2S0_WS, force=True)
fm.register(35, fm.fpioa.I2S0_IN_D0, force=True)
fm.register(34, fm.fpioa.I2S0_OUT_D2, force=True)
#app.ctrl.event(100, lambda *args: time.sleep(1))
#app.ctrl.event(10, app.on_event)
app.ctrl.event(5, app.draw)
#ui.enable = False
while True:
last = 0
while True:
try:
# print((int)(1000 / (time.ticks_ms() - last)), 'fps')
# last = time.ticks_ms()
# print_mem_free()
gc.collect()
app.ctrl.cycle()
protect.keep()
#time.sleep(0.1)
except KeyboardInterrupt:
protect.stop()
raise KeyboardInterrupt()
except Exception as e:
# gc.collect()
print(e)
def _init_hcho(self):
fm.register(34, fm.fpioa.UART3_TX, force=True)
fm.register(33, fm.fpioa.UART3_RX, force=True)
uart = UART(UART.UART3, 9600, 8, 0, 0, timeout=1000, read_buf_len=1024)
self.ws_h3 = WS_H3(uart, self.on_hcho_data)
# ws_h3.set_power_mode(low_power = False)
self.ws_h3.set_data_mode(active=False)
self.ws_h3_up_interval = 20 # s
self._ws_h3_last_up_t = -20
def _init_pm2_5(self):
fm.register(9, fm.fpioa.UART1_TX, force=True)
fm.register(10, fm.fpioa.UART1_RX, force=True)
uart = UART(UART.UART1, 9600, 8, 0, 0, timeout=1000, read_buf_len=1024)
self.pms7003 = PMS7003(uart, self.on_pm2_5_data)
self.pms7003.set_power_mode(low_power=False)
self.pms7003.set_data_mode(active=False)
self.pms7003_up_interval = 20 # s
self._pms7003_last_up_t = -20
def m5stickv_init():
lcd.init()
lcd.rotation(2)
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA) #QVGA=320x240
sensor.set_windowing((224, 224))
sensor.run(1)
fm.register(board_info.BUTTON_A, fm.fpioa.GPIO1)
but_a = GPIO(GPIO.GPIO1, GPIO.IN, GPIO.PULL_UP)
fm.register(board_info.BUTTON_B, fm.fpioa.GPIO2)
but_b = GPIO(GPIO.GPIO2, GPIO.IN, GPIO.PULL_UP)
def read_reg(reg_addr, buf_len):
for i in range(255): # i2c patch
try:
return TouchLow.i2c1.readfrom_mem(TouchLow.addr, reg_addr, buf_len, mem_size=8)
except OSError as e:
#print(e)
from fpioa_manager import fm
from Maix import GPIO
tmp = fm.fpioa.get_Pin_num(fm.fpioa.I2C1_SDA)
fm.register(tmp, fm.fpioa.GPIOHS15)
sda = GPIO(GPIO.GPIOHS15, GPIO.OUT)
sda.value(1)
fm.register(tmp, fm.fpioa.I2C1_SDA, force=True)
def init():
#整体初始化函数
lcd.init()
sensor.reset(freq=28000000, set_regs=True,
dual_buff=True) # Reset and initialize the sensor. It will
sensor.set_pixformat(
sensor.RGB565) # Set pixel format to RGB565 (or GRAYSCALE)
sensor.set_framesize(sensor.QVGA) # Set frame size to QVGA (320x240)
sensor.skip_frames(time=2000) # Wait for settings take effect.
sensor.set_vflip(True)
sensor.run(1)
fm.register(board_info.PIN15, fm.fpioa.UART1_TX, force=True)
fm.register(board_info.PIN17, fm.fpioa.UART1_RX, force=True)
def _writeReg(self, regAddr, data):
while True:
try:
return self.i2c_bus.writeto_mem(self.i2c_addr, regAddr, data, mem_size=8)
except OSError as e:
#print(e)
from fpioa_manager import fm
from Maix import GPIO
tmp = fm.fpioa.get_Pin_num(fm.fpioa.I2C1_SDA)
fm.register(tmp, fm.fpioa.GPIOHS15)
sda = GPIO(GPIO.GPIOHS15, GPIO.OUT)
sda.value(1)
fm.register(tmp, fm.fpioa.I2C1_SDA, force=True)
def __init__(self, mosi=8, miso=15, cs=20, clk=21):
self.is_load = False
self.spi = SPI(SPI.SPI_SOFT,
mode=SPI.MODE_MASTER,
baudrate=400 * 1000,
polarity=0,
phase=0,
bits=8,
firstbit=SPI.MSB,
sck=clk,
mosi=mosi,
miso=miso)
fm.register(cs, fm.fpioa.GPIO6, force=True)
self.cs = GPIO(GPIO.GPIO6, GPIO.OUT)
def connect_wifi(WIFI_SSID=None, WIFI_PASSWD=None):
if WIFI_SSID or WIFI_PASSWD:
# for new MaixGO board, if not, remove it
fm.register(0, fm.fpioa.GPIOHS1, force=True)
wifi_io0_en = GPIO(GPIO.GPIOHS1, GPIO.OUT)
wifi_io0_en.value(0)
# En ESP8285
fm.register(8, fm.fpioa.GPIOHS0, force=True)
wifi_en = GPIO(GPIO.GPIOHS0, GPIO.OUT)
fm.register(board_info.WIFI_RX, fm.fpioa.UART2_TX, force=True)
fm.register(board_info.WIFI_TX, fm.fpioa.UART2_RX, force=True)
def wifi_enable(en):
wifi_en.value(en)
def wifi_reset():
global uart
wifi_enable(0)
time.sleep_ms(200)
wifi_enable(1)
time.sleep(2)
uart = UART(UART.UART2, 115200, timeout=1000, read_buf_len=4096)
tmp = uart.read()
uart.write("AT+UART_CUR=921600,8,1,0,0\r\n")
print(uart.read())
# important! baudrate too low or read_buf_len too small will loose data
uart = UART(UART.UART2, 921600, timeout=1000, read_buf_len=10240)
uart.write("AT\r\n")
tmp = uart.read()
print(tmp)
if not tmp.endswith("OK\r\n"):
print("reset fail")
return None
try:
nic = network.ESP8285(uart)
except Exception:
return None
return nic
nic = wifi_reset()
if not nic:
raise Exception("WiFi init fail")
nic = network.ESP8285(uart)
err = 0
while True:
try:
nic.connect(WIFI_SSID, WIFI_PASSWD)
except Exception:
err += 1
print("Connect AP failed, now try again")
if err > 3:
raise Exception("Conenct AP fail")
continue
break
print(nic.ifconfig())
return nic.isconnected()
def _readReg(self, regAddr):
while True:
try:
self.i2c_bus.writeto(self.i2c_addr, bytes([regAddr]))
return (self.i2c_bus.readfrom(self.i2c_addr, 1))[0]
except OSError as e:
#print(e)
from fpioa_manager import fm
from Maix import GPIO
tmp = fm.fpioa.get_Pin_num(fm.fpioa.I2C1_SDA)
fm.register(tmp, fm.fpioa.GPIOHS15)
sda = GPIO(GPIO.GPIOHS15, GPIO.OUT)
sda.value(1)
fm.register(tmp, fm.fpioa.I2C1_SDA, force=True)
def uart_rec_start():
fm.register(board_info.PIN9, fm.fpioa.UART2_TX)
fm.register(board_info.PIN10, fm.fpioa.UART2_RX)
uart_A = UART(UART.UART1,
921600,
8,
None,
1,
timeout=1000,
read_buf_len=4096)
uart_B = UART(UART.UART2,
921600,
8,
None,
1,
timeout=1000,
read_buf_len=4096)
_thread.start_new_thread(uart_rec_task, ())
def initialize(uart_timeout):
"""Initialize the camera and lcd."""
lcd.init(freq=15000000)
sensor.reset(freq=20000000, set_regs=True, dual_buff=True)
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
sensor.set_hmirror(False)
sensor.set_vflip(False)
sensor.skip_frames(time=2000)
fm.register(board_info.PIN15, fm.fpioa.UART1_TX)
uart_A = UART(UART.UART1,
115200,
8,
0,
0,
timeout=uart_timeout,
read_buf_len=4096)
last_time = time()
return uart_A, last_time
def init():
if __class__.__is_m1w__:
fm.register(0, fm.fpioa.GPIOHS1, force=True)
M1wPower=GPIO(GPIO.GPIOHS1, GPIO.OUT)
M1wPower.value(0) # b'\r\n ets Jan 8 2013,rst cause:1, boot mode:(7,6)\r\n\r\nwaiting for host\r\n'
fm.register(board_info.WIFI_EN, fm.fpioa.GPIOHS0) # board_info.WIFI_EN == IO 8
__class__.en = GPIO(GPIO.GPIOHS0,GPIO.OUT)
fm.register(board_info.WIFI_RX,fm.fpioa.UART2_TX) # board_info.WIFI_RX == IO 7
fm.register(board_info.WIFI_TX,fm.fpioa.UART2_RX) # board_info.WIFI_TX == IO 6
__class__.uart = UART(UART.UART2, 115200, timeout=1000, read_buf_len=8192)
def load_application(selected):
if app.current != None: # clear last application
del app.current
app.current = None
if selected == 0:
pass
elif selected == 1:
app.current = pages()
app.current.tips = "Weclome to Maix Amigo"
elif selected == 2:
fm.register(9, fm.fpioa.I2C0_SCLK, force=True)
fm.register(7, fm.fpioa.I2C0_SDA, force=True)
CubeAudio.load(os.getcwd() + "/res/sound/loop.wav", 100)
app.points=[]
pass
#app.layer -= 1 # return last layer
#raise Exception("Settings Unrealized.")
elif selected == 3:
photos.scan()
def __init__(self, i2c, w, h, cycle=1000, irq_pin=33):
self.cycle = cycle
self.last_time = 0
self.points = [(0, 0, 0), (0, 0, 0)]
self.state = Touch.idle
self.width, self.height = w, h
# touch dirver init
if i2c == None:
i2c = I2C(I2C.I2C3, freq=100*1000, scl=24, sda=27) # amigo
TouchLow.config(i2c=i2c)
# 按压检测（中断）
self.events = []
setattr(self, "press_check_", self.press_check)
fm.register(irq_pin, fm.fpioa.GPIOHS28, force=True)
key = GPIO(GPIO.GPIOHS28, GPIO.IN, GPIO.PULL_DOWN)
key.irq(self.press_check_, GPIO.IRQ_FALLING, GPIO.WAKEUP_NOT_SUPPORT, 7)
# 添加松手检测（轮询）
system.event(20, self.release_check)
def wifi_enable(en):
fm.register(8, fm.fpioa.GPIOHS0)
wifi_en=GPIO(GPIO.GPIOHS0,GPIO.OUT)
fm.register(board_info.WIFI_RX,fm.fpioa.UART2_TX)
fm.register(board_info.WIFI_TX,fm.fpioa.UART2_RX)
wifi_en.value(en)
def draw_pages():
if app.current != None:
app.current.draw()
app.loop = (app.loop + 1) % 200
value = math.cos(math.pi * app.loop / 12) * 2 + 20
for i in range(100):
try:
#ui.canvas.draw_rectangle((240, 0, 240, 320), fill=False, thickness=3, color=(175, 175, 175))
if app.msa301 != None:
accel = app.msa301.acceleration
x, y = 240, 160 # center
#print(accel)
ui.canvas.draw_circle(x + int(accel[0] * 15), y + int(accel[1] * 20), int(value), fill=True,
color=(150 + int(accel[0] * 20), 150 + int(accel[1] * 20), 100 + int(accel[2] * 20))) # 10ms
ui.canvas.draw_circle(x + int(accel[0] * 15), y + int(accel[1] * 20), int(value) + 1, thickness=3, fill=False, color=(0, 0, 0)) # 10ms
else:
tmp = fm.fpioa.get_Pin_num(fm.fpioa.I2C1_SDA)
fm.register(tmp, fm.fpioa.GPIOHS15)
sda = GPIO(GPIO.GPIOHS15, GPIO.OUT)
sda.value(1)
fm.register(tmp, fm.fpioa.I2C1_SDA, force=True)
app.msa301 = MSA301(app.i2c1)
break
except Exception as e:
pass
# gc.collect()
#ui.canvas.draw_string(240 + 10, 140, "x", (255, 0, 0), scale=2)
#ui.canvas.draw_string(240 + 10, 140, "x", (255, 0, 0), scale=2)
#ui.canvas.draw_line(240 + 120, 150, 120 + int(accel[0] * 8), 150, color=(41, 131, 255))
#ui.canvas.draw_string(240 + 10, 160, "y", (0, 255, 0), scale=2)
#ui.canvas.draw_line(240 + 120, 170, 120 + int(accel[1] * 8), 170, color=(141, 31, 255))
#ui.canvas.draw_string(240 + 10, 180, "z", (0, 0, 255), scale=2)
#ui.canvas.draw_line(240 + 120, 190, 120 + int(accel[2] * 8), 190, color=(241, 131, 55))
ui.display()
def config(ENTER=10, BACK=11, NEXT=16):
fm.register(ENTER, fm.fpioa.GPIOHS0 + ENTER, force=True)
fm.register(NEXT, fm.fpioa.GPIOHS0 + NEXT, force=True)
fm.register(BACK, fm.fpioa.GPIOHS0 + BACK, force=True)
button_io.home_button = GPIO(GPIO.GPIOHS0 + ENTER, GPIO.IN, GPIO.PULL_UP)
button_io.next_button = GPIO(GPIO.GPIOHS0 + NEXT, GPIO.IN, GPIO.PULL_UP)
button_io.back_button = GPIO(GPIO.GPIOHS0 + BACK, GPIO.IN, GPIO.PULL_UP)
def check(self):
try:
if self.isconnected == False:
self.isconnected = CubeAudio.check()
else:
if self.state == 0 and self.is_play == False:
self.is_play = True
CubeAudio.ready()
from fpioa_manager import fm
fm.register(19, fm.fpioa.I2S0_MCLK, force=True)
fm.register(35, fm.fpioa.I2S0_SCLK, force=True)
fm.register(33, fm.fpioa.I2S0_WS, force=True)
fm.register(34, fm.fpioa.I2S0_IN_D0, force=True)
fm.register(18, fm.fpioa.I2S0_OUT_D2, force=True)
# CubeAudio.i2s.set_sample_rate(22050)
elif self.state == 1 and self.is_record == False:
self.is_record = True
CubeAudio.ready(True)
CubeAudio.i2s.set_sample_rate(22050)
except Exception as e:
#Report.Audio_Test = False
Report.isError = str(e)
print(e)
def wifi(): #wifi
from aibit import *
print("开始WIFI模块测试...")
lcd.draw_string(30, 50, 'Start test WIFI (End by touch) ', lcd.RED, lcd.BLACK)
uart = UART(UART.UART2,115200,timeout=1000, read_buf_len=4096)
wifi_enable(1)
time.sleep_ms(200)
wifi_enable(1)
time.sleep_ms(200)
fm.register(9, fm.fpioa.GPIO1)
key_4 = GPIO(GPIO.GPIO1,GPIO.IN,GPIO.PULL_UP)
read = uart.read()
print(read)
i=1
while (key_4.value() == 1):
#print(read[11:26])
uart.write("AT+GMR\r\n")
time.sleep_ms(200)
read = uart.read()
print(read)
#read = read.decode(“utf-8”)
try:
lcd.draw_string(20, 90, 'Ver:' + str(read[11:38]+')'), lcd.RED, lcd.BLACK)
lcd.draw_string(50, 90, ' ', lcd.RED, lcd.BLACK)
except TypeError:
print ("Error: 没有找到有效版本号")
lcd.draw_string(50, 160, 'WIFI test failed!!! ', lcd.GREEN, lcd.BLACK)
time.sleep(0.05)
if i > 10:
break
i +=1
print("WIFI模块测试完成")
time.sleep(3)
lcd.clear()
def __init__(self, ssid=None, passwd=None):
if not ssid:
raise Exception("no SSID")
self.ssid = ssid
self.passwd = passwd
print("[init SSID:", ssid, ", PASSWD:", passwd)
fm.register(0, fm.fpioa.GPIOHS1, force=True)
wifi_io0_en = GPIO(GPIO.GPIOHS1, GPIO.OUT)
wifi_io0_en.value(0)
fm.register(8, fm.fpioa.GPIOHS0)
self.wifi_en = GPIO(GPIO.GPIOHS0, GPIO.OUT)
fm.register(board_info.WIFI_RX, fm.fpioa.UART2_TX)
fm.register(board_info.WIFI_TX, fm.fpioa.UART2_RX)
self.uart = UART(UART.UART2, 115200, timeout=1000, read_buf_len=4096)
self.update_step = 0
class wifi():
# IO map for ESP32 on Maixduino
fm.register(25,fm.fpioa.GPIOHS10)#cs
fm.register(8,fm.fpioa.GPIOHS11)#rst
fm.register(9,fm.fpioa.GPIOHS12)#rdy
print("Use Hareware SPI for other maixduino")
fm.register(28,fm.fpioa.SPI1_D0, force=True)#mosi
fm.register(26,fm.fpioa.SPI1_D1, force=True)#miso
fm.register(27,fm.fpioa.SPI1_SCLK, force=True)#sclk
nic = network.ESP32_SPI(cs=fm.fpioa.GPIOHS10, rst=fm.fpioa.GPIOHS11, rdy=fm.fpioa.GPIOHS12, spi=1)
from board import board_info
from fpioa_manager import fm
from Maix import GPIO
import sensor, lcd
lcd.init()
lcd.rotation(2)
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
#sensor.set_vflip(1)
#sensor.set_hmirror(1)
sensor.run(1)
sensor.skip_frames(time=2000)
fm.register(35, fm.fpioa.UART1_TX, force=True)
fm.register(34, fm.fpioa.UART1_RX, force=True)
uart = UART(UART.UART1, 115200, 8, 0, 0, timeout=1000, read_buf_len=4096)
while (True):
img = sensor.snapshot()
lcd.display(img)
buf = uart.readline()
if buf and len(buf) == 3:
print(buf)
img_buf = img.compress(quality=50)
sz = img_buf.size()
img_size1 = (sz & 0xFF0000) >> 16
img_size2 = (sz & 0x00FF00) >> 8
img_size3 = (sz & 0x0000FF) >> 0
## Copyright (c) 2019 aNoken
import network, lcd
from Maix import GPIO
from fpioa_manager import fm, board_info
# IO map for ESP32 on Maixduino
fm.register(25, fm.fpioa.GPIOHS10) #SPI cs
fm.register(8, fm.fpioa.GPIOHS11) #rst
fm.register(9, fm.fpioa.GPIOHS12) #rdy
fm.register(28, fm.fpioa.GPIOHS13) #SPI mosi
fm.register(26, fm.fpioa.GPIOHS14) #SPI miso
fm.register(27, fm.fpioa.GPIOHS15) #SPI sclk
lcd.init()
lcd.clear()
nic = network.ESP32_SPI(cs=fm.fpioa.GPIOHS10,
rst=fm.fpioa.GPIOHS11,
rdy=fm.fpioa.GPIOHS12,
mosi=fm.fpioa.GPIOHS13,
miso=fm.fpioa.GPIOHS14,
sclk=fm.fpioa.GPIOHS15)
print("ESP32_SPI firmware version:", nic.version())
enc_str = ["OPEN", "", "WPA PSK", "WPA2 PSK", "WPA/WPA2 PSK"]
aps = nic.scan()
cnt = 0
for ap in aps:
enc_1 = "SSID:{:^20}".format(ap[0])
