def correr(nombre):
buzComun = sysvmq.Queue(420)
sid = nombre #Identificador
#print("Corriendo: " + str(sid))
buz = sysvmq.Queue(nombre) #crea buzon
while True:
print(nombre)
#time.sleep(2)
pack = buz.get()
print (pack)
#info = struct.unpack('BIBBBBBf',pack)
if( pack[2]== 5 and (pack[6] == 6 or pack[6] == 8) ):
tipoDato = 2 #Tipo dato 2 es flotante
infoUtil = struct.pack('IIfB',sid,pack[1],pack[7],tipoDato)
buzComun.put(infoUtil)
elif ( pack[2] == 6):
tipoDato = 1 #Tipo dato 1 es entero
infoUtil = struct.pack('IIfB',sid,pack[1],pack[7],tipoDato)
buzComun.put(infoUtil)
else:
tipoDato = 0 #Tipo dato 0 es booleano
infoUtil = struct.pack('IIfB',sid,pack[1],pack[7],tipoDato)
buzComun.put(infoUtil)
from ipcqueue import sysvmq # Biblioteca para los buzones.
import struct
#FORMAT = 'BIBBBBBf'
buzComun = sysvmq.Queue(420)
infoUtil = struct.pack('=IIfB', 52, 2, 57, 1) #Dato a leer 1
print(infoUtil)
i = 0
while (True):
buzComun.put(infoUtil)
i += 1
from ipcqueue import sysvmq
values = []
#UDP_IP = "10.1.137.196"
UDP_IP = "127.0.0.1"
UDP_PORT = 5005
time.sleep(5) # Test the client's timeout
sock = socket.socket(
socket.AF_INET, # Internet
socket.SOCK_DGRAM) # UDP
sock.bind((UDP_IP, UDP_PORT))
q = sysvmq.Queue(2)
s = struct.Struct("BIBBBBBf")
ss = struct.Struct("BBBBB")
sss = struct.Struct("BIBBf")
while True:
readable = select.select([sock], [], [], 6)
if readable[0]:
data, addr = sock.recvfrom(1024) # buffer size is 1024 bytes
values = s.unpack(data)
dtime = time.ctime(values[1])
#values[0] => Random(ACK)
#values[1] => Time
#values[2] => Team Id
#values[3] => Sensor Id
#values[4] => Sensor Id
#values[5] => Sensor Id
from ipcqueue import sysvmq
# ~ from typing import NamedTuple
from time import time
#import time
import struct
import random
import select
sensorId = [0x00,0x01,0x02]
values = []
values.append(random.randint(0,255))
values.append(int(time()))
values.append(4) #TeamID
q = sysvmq.Queue(1)
s = struct.Struct('BIBBBBBf')
sensorData = struct.Struct('BBf')
UDP_IP = "127.0.0.1"
#UDP_IP = "10.1.137.67"
UDP_PORT = 5005
sock = socket.socket(socket.AF_INET, # Internet
socket.SOCK_DGRAM) # UDP
checker = False
while True:
checker = False
packet = q.get(block=True, msg_type=1)
packArray = sensorData.unpack(packet)
# ~ q.put(data, msg_type=1)
# ~ elif sys.argv[1] == '5': #404 sensors
# ~ data = ss.pack(5)
# ~ q.put(data, msg_type=1)
# ~ elif sys.argv[1] == '6': #Poffis sensors
# ~ print "Poffis seleccionado"
# ~ data = ss.pack(6)
# ~ q.put(data, msg_type=1)
# ~ else:
# ~ print "Grupo desconocido\n"
# ~ else:
# ~ print "El uso de graphics es python graphics.py [IDGrupo]\n"
if len(sys.argv) == 3: # Contiene el numero de grupo y el numero de sensor
q = sysvmq.Queue(15)
mainQueue = sysvmq.Queue(2)
s = struct.Struct("BIBBf")
ss = struct.Struct("II")
dataType = 0
graphicsName = [
"Whitenoise Movimiento", "Whitenoise Big Sound", "Flamingo Movimiento",
"Flamingo Fotoresistor", "Gisso Movimiento", "Gisso Shock",
"KOF Movimiento", "KOF Touch", "404 Movimiento", "404 Humedad",
"404 Temperatura", "Poffis Humedad", "Poffis Big Sound"
]
if ((sys.argv[2] == '6' or sys.argv[2] == '8') and (sys.argv[1] == '5')):
dataType = 2 #Float data type
elif (sys.argv[2] == '1' or sys.argv[2] == '2' or sys.argv[2] == '3'
#import RPi.GPIO as GPIO
import socket
import time
import datetime
import random
from ipcqueue import sysvmq as SYSV
#GPIO.setmode(GPIO.BCM)
#GPIO_PIR = 26
#GPIO.setup(GPIO_PIR, GPIO.IN)
buzon = SYSV.Queue(63)
cambioDeEstado = 1
#file = open("datos.txt", "w+")
try:
while True:
valor = random.randint(0, 1)
#este if es del keep alive
if cambioDeEstado == valor:
now = time.time()
buzon.put([2, 1, now])
#file.write("Intruder detected. Date " + now.strftime("%d/%m/%Y Time %Hh:%Mm:%Ss") + "\n")
print("Keep Alive " + str(time.ctime(now)))
#print(buzon.get())
else:
if valor:
now = time.time()
buzon.put([1, 1, now])
#file.write("Intruder detected. Date " + now.strftime("%d/%m/%Y Time %Hh:%Mm:%Ss") + "\n")
print("Intruder " + str(time.ctime(now)))
import RPi.GPIO as GPIO
import time
from ipcqueue import sysvmq
pir = 27
GPIO.setmode(GPIO.BCM)
GPIO.setup(pir, GPIO.IN)
date = int(time.time())
q = sysvmq.Queue(1) # Crea el buzon con la llave 1
while True:
if GPIO.input(pir): # Si detecto actividad en ese pin
print("Signal detected")
q.put(int(time.time())) # Agrega el tiempo en que se detecto al buzon
else:
q.put(
0
) # Agrega 0 al buzon indicando que no se detecto movimiento, seria el keepalive
time.sleep(1) # Espera 1 segundo.
import select
from ipcqueue import sysvmq as SYSV
UDP_IP = "127.0.0.1"
UDP_PORT = 10001
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.settimeout(5)
saved_data = []
last_id = 0
queue_overflow = False
empty_queue = 1
my_queue = SYSV.Queue(63)
my_queue_attributes = my_queue.qattr()
my_queue_max_size = my_queue_attributes['max_bytes']
class myPackage:
random_id = 0
date = 0
sensor_id = bytearray([0x02, 0x00, 0x00, 0x00])
sensor_type = 0x00
data = 0.0
my_pack = myPackage()
from ipcqueue import sysvmq # Biblioteca para los buzones.
UDP_IP = "192.168.5.75" #IP a enviar
MINE = "192.168.1.65" # Mi ip, para el bind
UDP_PORT = 10001
SHOCK_ID = 0x04
MOV_ID = 0x01
KEEP_ALIVE = 0x0
TEAM_ID = 0x03
BOOL_TYPE = 0x01
FORMAT = 'BIBBBBBf'
shock = sysvmq.Queue(
1
) # Se crea el buzon con la llave 1 para que se conecte con el creado en shock.py
mov = sysvmq.Queue(
2
) # Se crea con la llave 2 para que se conecte con el creado en movement.py
lastRandomId = 0
randomId = -1
sock = socket.socket(
socket.AF_INET, # Abrir los sockets
socket.SOCK_DGRAM) #
sock.bind((MINE, UDP_PORT)) # Crea la conexion
# Metodo que envia el paquete al cliente.
def crearThread(identificador): x = threading.Thread(target=correr, args=(identificador,)) buz =sysvmq.Queue(identificador) #crea buzon diccionario.setdefault(identificador,buz) # z=key del buzon x.start()
import random
from ipcqueue import sysvmq
import pdb
import socket
#IPDistribuida = 192.168.1.100
PORT = 2000 # Port to listen on (non-privileged ports are > 1023)
#IPDistribuida = '10.1.137.53'
IPDistribuida = '127.0.0.1'
numeroPagina = 0
tamanoPaginaTotal = 84600
memoriaPrincipal = [] #Memoria principal o local
#Hay que agregar frame table
pageArray = [] # Contiene los ID Pagina que estan en memoria Local
numeroFilasMemoria = 4 #Tamano de la memoria local
contadorFilaActual = 0
buzonLlamados = sysvmq.Queue(17)
buzonRetornos = sysvmq.Queue(16)
buzonParametros = sysvmq.Queue(15)
contadorPrueba = 0
#Codigos de llamados
#HabilitarPagina = 0
#pedirPagina =1
#guardar=2
#Se crea socket para la comunicacion con la ID
socket_send = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print("Antes del connect")
socket_send.connect((IPDistribuida, PORT))
print("Despues del connect")
import time
import datetime
import select
import sys
import os
from ipcqueue import sysvmq as SYSV
import matplotlib
import matplotlib.pyplot as plt
import numpy as np
import plotly.graph_objects as go
buzon = SYSV.Queue(15)
datos1 = []
datos2 = []
bin_count = 5
def convert_time(bin_maxes):
for i in range(len(bin_maxes)):
tiempo = time.strftime("%m/%d/%Y, %H:%M:%S",
time.localtime(bin_maxes[i]))
bin_maxes[i] = tiempo
return bin_maxes
def count_bins(min_meas, max_meas):
bin_width = (max_meas - min_meas) / bin_count
bin_maxes = []
bin_counts1 = []
bin_counts2 = []
#Imports
import socket
from ipcqueue import sysvmq
import struct
import memory_manager as memory_manager
#Imports
page_table = dict()
queueR = sysvmq.Queue(2)
queueS = sysvmq.Queue(15)
s = struct.Struct("II")
ss = struct.Struct("BIBBf")
values = []
lastId = 0
def malloc_maravilloso(sensorId, teamId):
global page_table
global lastId
lastId += 1
page = memory_manager.create_page(lastId)
page_table[str((sensorId + teamId))] = ProcessInfo()
print(str((sensorId + teamId)))
page_table[str((sensorId + teamId))].last = page
page_table[str((sensorId + teamId))].list.append(page)
# def store(sensorId, teamId, date, data):
# coding: utf8 import time import datetime import struct from ipcqueue import sysvmq formatoFloat = 'If' formatoInt = 'II' formatoBool = 'IB' matrizRetorno = [] buzonLlamadoGraficador=sysvmq.Queue(69) buzonRetornoGraficador=sysvmq.Queue(469) x_eje = [] # Datos que delimitan y_eje = [] # la grafica cantidad_y = [] datos_y = [] tipoDato = 0 # Obtiene la hora de cada paquete. Linea comentada seria la final, comentada por testeo def getHour(packet): global tipoDato formato = formatoBool if(tipoDato == 1): formato = formatoBool elif (tipoDato == 2): formato = formatoInt
import time
from ipcqueue import sysvmq
i = 0
buzonLlamadoGraficador = sysvmq.Queue(69)
while (i < 5):
buzonLlamadoGraficador.put(i)
i += 1
time.sleep(5)
# coding: utf8
import struct
import time
import random
from ipcqueue import sysvmq
import threading
pageTable = []
tamanoPT = 0 #Tamano page table
FORMAT = '=IIfB' # IdentificadorSensor,fecha, dato,bit para verificar dato.
buzonGeneral = sysvmq.Queue(420)#Buzon para procesos recolectores
buzonLlamados = sysvmq.Queue(17)#Buzon para solicitar al administrador meter datos.
buzonRetornos = sysvmq.Queue(16)#Buzon para recibir la respuesta del administrador.
buzonParametros = sysvmq.Queue(15)
buzonLlamadoGraficador = sysvmq.Queue(69)
buzonRetornoGraficador = sysvmq.Queue(469)
def mallocMaravilloso(sensorId): #Agrego en la page table y despues habilito pagina en memoria principal
global pageTable,tamanoPT #Y despues meto el numero de pagina en la page table
pageTable.append([])
pageTable[tamanoPT].append(sensorId)
buzonLlamados.put(0) #Para llamar a habilitarPagina()
print("Llame al habilitar")
nuevaPag = buzonRetornos.get()
#Agrego la nueva pagina a la page table
pageTable[tamanoPT].append(nuevaPag)
tamanoPT += 1
print("PageTable ",pageTable)
def getPaginasSensor(sensorId):# Busca en la page table y retorna los numeros de pagina referentes a un sensorId, lo utiliza pedirDatos()
# coding=utf-8
import os
import time
import sys
import threading
import administradorMem
import struct
from ipcqueue import sysvmq as SYSV
colector_queue = SYSV.Queue(14) # cola para recolector
plotter_queue = SYSV.Queue(15) # cola para graficador
first_time = False # variable que revisa si es la primera vez que se ejecuto el programa
lock = threading.Lock() # lock para los threads
memory_admin = administradorMem.AdministradorMem() # instancia del administrador de memoria
# -----------------
# Metodo run que va a correr los threads
# Usa locks en zonas criticas para prevenir condiciones de carrera
# -----------------
class threadsInterface(threading.Thread):
def __init__(self, name):
threading.Thread.__init__(self)
self.name = name
self.kill = False
def run(self):