Código de interfaz final con Máquinas de vector soporte y

from tkinter import * import tkinter as tk from PIL import Image import time

import argparse import numpy as np import pandas as pd import matplotlib

matplotlib.use('TkAgg')

import matplotlib.pyplot as plt from pylab import *

from unipath import Path import matplotlib

import pyglet import serial import brainflow

from brainflow.board_shim import BoardShim, BrainFlowInputParams

from brainflow.data_filter import DataFilter, FilterTypes, AggOperations

from sklearn.multiclass import OneVsOneClassifier from sklearn.svm import LinearSVC

val='Inicio'

ser = serial.Serial("COM3",9600)

root = tk.Tk()

root.title("Ventana de pruebas") root.config(bg="black")

root.geometry("850x900")

animation= pyglet.image.load_animation('Conteo_regresivo.gif') bin = pyglet.image.atlas.TextureBin()

animation.add_to_texture_bin(bin)

#sprite =pyglet.sprite.Sprite(animation, x=200, y=50) sprite =pyglet.sprite.Sprite(animation, x=150, y=50)

#Conteo_regresivo 40

#mov_1_3s 64

#mov_2_3s 54

#pinza 62

#w= 700 Con contador

#h= 300 Con Contador

w= 950 h= 500 a=0 b=0 c=0

entrada=0

def clasificacion():

print('Clasificacion') global entrada

from sklearn.model_selection import train_test_split from sklearn.preprocessing import StandardScaler from sklearn.discriminant_analysis import

LinearDiscriminantAnalysis as LDA

from sklearn.linear_model import LogisticRegression from sklearn.metrics import confusion_matrix

dataset1 = pd.read_csv('BDParaLDATotal.csv') dataset2 = pd.read_csv('TargetM1M2M3.csv')

X = dataset1.iloc[0::,:].values y = dataset2.iloc[:,0].values

X=pd.DataFrame((X)) y=pd.DataFrame((y))

X_train1, X_test1, y_train1, y_test1 =

train_test_split(X.loc[0:99,:], y.loc[0:99] , test_size = 0.4, random_state =34)

X_train2, X_test2, y_train2, y_test2 =

train_test_split(X.loc[100:199,:], y.loc[100:199] , test_size = 0.4, random_state =34)

X_train3, X_test3, y_train3, y_test3 =

train_test_split(X.loc[200:299,:], y.loc[200:299] , test_size = 0.4, random_state =34)

X_1 = pd.concat([X_train1,X_test1]) X_2 = pd.concat([X_train2,X_test2]) X_3 = pd.concat([X_train3,X_test3])

X_1a=X_1.iloc[0:25,:]

X_1b=X_1.iloc[25:50,:]

X_1c=X_1.iloc[50:75,:]

X_1d=X_1.iloc[75:100,:]

X_2a=X_2.iloc[0:25,:]

X_2b=X_2.iloc[25:50,:]

X_2c=X_2.iloc[50:75,:]

X_2d=X_2.iloc[75:100,:]

X_3a=X_3.iloc[0:25,:]

X_3b=X_3.iloc[25:50,:]

X_3c=X_3.iloc[50:75,:]

X_3d=X_3.iloc[75:100,:]

Xunido1=pd.concat([X_1b,X_1c,X_1d,X_1a]) Xunido2=pd.concat([X_2b,X_2c,X_2d,X_2a]) Xunido3=pd.concat([X_3b,X_3c,X_3d,X_3a])

X_train1 = Xunido1.iloc[0:60,:]

X_test1 = Xunido1.iloc[60:100,:]

print(X_train1.shape)

X_train2 = Xunido2.iloc[0:60,:]

X_test2 = Xunido2.iloc[60:100,:]

print(X_train2.shape)

X_train3 = Xunido3.iloc[0:60,:]

X_test3 = Xunido3.iloc[60:100,:]

X_train = pd.concat([X_train1,X_train2,X_train3]) X_train=pd.DataFrame(X_train)

#X_test = pd.concat([X_test1,X_test2,X_test3]) y_train = pd.concat([y_train1,y_train2,y_train3])

#y_test = pd.concat([y_test1,y_test2,y_test3])

ClasificadorFinal =

pd.read_csv('ArregloDeDatosClasificadorSSMVSVrms.csv') [Filas33,Columnas33]=ClasificadorFinal.shape

X_test = ClasificadorFinal y_test = np.zeros(Filas33)

# Ajuste de Escalas sc = StandardScaler()

#Clasificacion de Maquinas de Vector Soporte

clf = OneVsOneClassifier(LinearSVC(random_state=0)).fit(X_train, y_train)

y_pred = clf.predict(X_test)

if y_pred[Filas33-1]==0:

print('Derecha') entrada=4

elif y_pred[Filas33-1]==1:

entrada=2

print('Izquierda') elif y_pred[Filas33-1]==2:

print('Mano') entrada=6

#DataFilter.write_file(y_pred, 'I_R_ssmv_vrms.csv', 'w') # use 'a' for append mode

def pulsarGuardar():

global val

val=nombre.get() print(val)

def activacion_pin():

juego=str(entrada)

ser.write(juego.encode('ascii'))

print('se ha enviado el valor', entrada)

def toma_datos():

global board global data

MovientoAClasificar=0 print('aqui llego')

BoardShim.enable_dev_board_logger()

parser = argparse.ArgumentParser()

# use docs to check which parameters are required for specific board, e.g. for Cyton - set serial port

parser.add_argument('--timeout', type=int, help='timeout for device discovery or connection', required=False,

default=0) print('aqui llego 2')

parser.add_argument('--ip-port', type=int, help='ip port', required=False, default=0)

parser.add_argument('--ip-protocol', type=int, help='ip protocol, check IpProtocolType enum', required=False,

default=0)

parser.add_argument('--ip-address', type=str, help='ip address', required=False, default='')

#parser.add_argument('--serial-port', type=str, help='serial port', required=False, default='')

parser.add_argument('--mac-address', type=str, help='mac address', required=False, default='')

parser.add_argument('--other-info', type=str, help='other info', required=False, default='')

parser.add_argument('--streamer-params', type=str, help='streamer params', required=False, default='')

parser.add_argument('--serial-number', type=str, help='serial number', required=False, default='')

#parser.add_argument('--board-id', type=int, help='board id, check docs to get a list of supported boards',

# required=True)

parser.add_argument('--file', type=str, help='file', required=False, default='')

args = parser.parse_args()

params = BrainFlowInputParams() params.ip_port = args.ip_port params.serial_port = 'COM4'

params.mac_address = args.mac_address params.other_info = args.other_info

params.serial_number = args.serial_number

params.ip_address = args.ip_address params.ip_protocol = args.ip_protocol params.timeout = args.timeout

params.file = args.file

board = BoardShim(0, params) board.prepare_session()

#board.start_stream () # use this for default options

board.start_stream(45000, args.streamer_params) time.sleep(6)

print('tomando datos')

data = board.get_board_data() # get all data and remove it from internal buffer

def ArreglarDatos():

ConFiltroM1M2M3 =

DataFilter.read_file('MovimientoAClasificarCFSSMVSVrms.csv') ConFiltroM1M2M3 = pd.DataFrame(ConFiltroM1M2M3)

ConFiltroM1M2M3 = ConFiltroM1M2M3.T [fil,colum] =ConFiltroM1M2M3.shape

for j in np.arange(0,fil,1300):

#print(j) nn=[]

for i in np.arange(1,9):

for k in range(0,1300):

nn=pd.DataFrame(nn)

nn.loc[1,(1300*(i-1))+k]=ConFiltroM1M2M3.iloc[k+j,i]

print('el numero es:') print(nn.loc[1,1]) if j==0:

n1=nn

n1=pd.DataFrame(n1) else:

n1=n1.append(nn,ignore_index=True) BDParaLDA=pd.DataFrame(data=n1)

BDParaLDA.to_csv('ArregloDeDatosClasificadorSSMVSVrms.csv',sep=',',flo at_format='%.6f',index=False)

def parar_toma_datos(MovientoAClasificar):

print(val)

board.stop_stream() board.release_session()

DataFilter.write_file(data, 'DatosSinProcesarSSMVSVrms.csv', 'w')

# use 'a' for append mode

datos = np.asarray(data)

datos=np.delete(datos, 0, axis=1)

datos=np.delete(datos, (9,10,11,12,13,14,15,16,17,18,19,20,21,22), axis=0)

datos=np.delete(datos, np.s_[1300::1], axis=1)

print('este es el movimiento numero: '+ str(MovientoAClasificar)) var = np.asarray(val)

if MovientoAClasificar==1:

f = Path('NombreDeUsuario.csv')#Targets Movimiento 1 if(f.exists()):

df=pd.read_csv('NombreDeUsuario.csv') N=np.asarray(df)

N=np.append(N,var)

N=pd.DataFrame(data=N)

N.to_csv('NombreDeUsuario.csv',sep=' ',float_format='%.2f',index=False)

print(f.exists()) else:

T1=[var]

T1=pd.DataFrame(data=T1)

T1.to_csv('NombreDeUsuario.csv',sep=' ',float_format='%.2f',index=False)

f = Path('MovimientoAClasificarSFSSMVSVrms.csv')#Movimiento uno sin filtro

if(f.exists()):

DatosConProcesamiento1 =

pd.read_csv('MovimientoAClasificarSFSSMVSVrms.csv')

DataFilter.write_file(datos,

'MovimientoAClasificarSFSSMVSVrms.csv', 'a') # use 'a' for append mode

print(f.exists()) else:

DataFilter.write_file(datos,

'MovimientoAClasificarSFSSMVSVrms.csv', 'w') # use 'a' for append mode

#datos = np.asarray(data)

#np.savetxt("TimeSleep.csv", np.transpose(datos), fmt="%d", delimiter=",")

eeg_channels = board.get_eeg_channels(0)

for count, channel in enumerate(eeg_channels):

DataFilter.perform_rolling_filter(datos[channel], 3, AggOperations.MEDIAN.value)

f = Path('MovimientoAClasificarCFSSMVSVrms.csv') #Movimiento 1 con procesamiento

#print(f.exists())

if(f.exists()):

DatosConProcesamiento1 =

pd.read_csv('MovimientoAClasificarCFSSMVSVrms.csv')

DataFilter.write_file(datos,

'MovimientoAClasificarCFSSMVSVrms.csv', 'a') # use 'a' for append mode

print(f.exists()) else:

DataFilter.write_file(datos,

'MovimientoAClasificarCFSSMVSVrms.csv', 'w') # use 'a' for append mode

#Movimiento 1 def start():

MovientoAClasificar=1 print(MovientoAClasificar) toma_datos()

print('Inicia toma de datos')

window = pyglet.window.Window(width=w, height=h) window.set_location(10,10)

@window.event def on_draw():

global a

sprite.draw() a += 1

if a == 40:

a=0

print('Finalizo toma datos')

parar_toma_datos(MovientoAClasificar)

ArreglarDatos() clasificacion() activacion_pin() print(entrada) pyglet.app.exit()

pyglet.app.run() window.close()

boton1=tk.Button(root, text="INICIAR", bg="limegreen",

font=("Verdana",18), width=10,command= start ).place(x=340,y=530) boton6=tk.Button(root, text="Guardar", bg="sandybrown",

command=pulsarGuardar).place(x=540,y=600) nombre=StringVar()

NombreLabel= Label(root, text="Nombre", fg="white", bg="black").place(x=250,y=600)

CuadroNombre= Entry(root, width=32, textvariable=nombre).place( x=320, y=600)

root.mainloop() '''if Deci==0:

entrada=1

activacion_pin() if Deci==1:

entrada=2

activacion_pin() if Deci==2:

entrada=3

activacion_pin() '''

In document implementación de interfaz cerebro-máquina para el control (página 108-119)