I'm programming a Java client which sends an image as byte array and a Python server to receive the image. Received image height, width, channels are right,
sock = socket.socket()
sock.bind(('localhost', 8080))
sock.listen(1)
print ("Listen")
conn, addr = sock.accept()
print('Start server')
while True:
data = conn.recv(1024)
if not data:
break
img = cv2.imdecode(np.fromstring(io.BytesIO(data).getvalue(), dtype=np.uint8), 1)
np.save('snapshot.npy',img)
exit()
Showing the image using cv2.imshow('img', img) gives an incorrect result:
Java side:
public class Client implements Runnable {
private Socket socket;
private DataOutputStream out;
private String server;
private int port;
private ArrayList<ResponseListener> listeners = new ArrayList<>();
public void addListener(ResponseListener responseListener){
listeners.add(responseListener);
}
public void removeListeners(ResponseListener responseListener){
listeners.remove(responseListener);
}
Client(String server, int port) {
this.server = server;
this.port = port;
}
public void start(){
while(socket==null){
try {
socket = new Socket(server, port);
socket.setTcpNoDelay(true);
System.out.println("Ready");
listeners.forEach((listener)->listener.serverIsReady());
} catch (Exception ex) {
System.out.println("In thread " + ex.toString());
}
}
}
public void send(byte[] img) throws IOException {
out.write(img);
}
#Override
public void run() {
InputStreamReader in = null;
try {
in = new InputStreamReader(socket.getInputStream());
System.out.println(in);
out = new DataOutputStream(socket.getOutputStream());
} catch (IOException e) {
System.out.println("in or out failed");
System.exit(-1);
}
int count = 0;
while (true) {
try {
int line = in.read();
count++;
if(count==4) {
listeners.forEach((listener)->listener.onSignDefined(String.valueOf(line)));
count=0;
}
} catch (Exception e) {
System.out.println("In loop " + e.toString());
System.exit(-1);
}
}
}
}
I solved problem. Solution really easy:
data = conn.recv(640*480*3)
640*480*3 - size of image
Related
So I want to send and receive from/to Unity and Python in the same run.
I have the following components for the communication.
TCPSendPipe - Sends data from Unity to Python
TCPListePipe - Receives data from Python
Python Script - Send (uses socket.connect) and Receive (uses socket.bind)
At the moment I can only use one at a time either,
TCPSendPipe with Python receive or,
TCPListenPipe with Python send
Following are the scripts:
TCPSendPipe.cs
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Net.Sockets;
using UnityEngine;
public class TCPSendPipe : MonoBehaviour
{
public String Host = "localhost";
public Int32 Port = 55000;
TcpClient mySocket = null;
NetworkStream theStream = null;
StreamWriter theWriter = null;
public GameObject robot;
public Vector3 robPos;
// Start is called before the first frame update
void Start()
{
robot = GameObject.Find("robot");
mySocket = new TcpClient();
if (SetupSocket())
{
Debug.Log("socket is set up");
}
}
// Update is called once per frame
void Update()
{
robPos = robot.transform.position;
Debug.Log(robPos);
if (!mySocket.Connected)
{
SetupSocket();
}
sendMsg();
}
public void sendMsg()
{
theStream = mySocket.GetStream();
theWriter = new StreamWriter(theStream);
//Byte[] sendBytes = System.Text.Encoding.UTF8.GetBytes("yah!! it works");
Byte[] sendBytes = procData();
mySocket.GetStream().Write(sendBytes, 0, sendBytes.Length);
}
public bool SetupSocket()
{
try
{
mySocket.Connect(Host, Port);
Debug.Log("socket is sent");
return true;
}
catch (Exception e)
{
Debug.Log("Socket error: " + e);
return false;
}
}
public Byte[] procData()
{
Byte[] bytes = new Byte[12]; // 4 bytes per float
Buffer.BlockCopy( BitConverter.GetBytes( robPos.x ), 0, bytes, 0, 4 );
Buffer.BlockCopy( BitConverter.GetBytes( robPos.y ), 0, bytes, 4, 4 );
Buffer.BlockCopy( BitConverter.GetBytes( robPos.z ), 0, bytes, 8, 4 );
return bytes;
}
private void OnApplicationQuit()
{
if (mySocket != null && mySocket.Connected)
mySocket.Close();
}
}
TCPListenPipe.cs
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Text;
using System.Globalization;
using System.Net.Sockets;
using UnityEngine;
public class TCPListenPipe : MonoBehaviour
{
public String Host = "localhost";
public Int32 Port = 55000;
IPAddress localAddr = IPAddress.Parse("127.0.0.1");
private TcpListener listener = null;
private TcpClient client = null;
private NetworkStream ns = null;
string msg;
// Start is called before the first frame update
void Awake()
{
listener = new TcpListener(localAddr, Port);
listener.Start();
Debug.Log("is listening");
if (listener.Pending())
{
client = listener.AcceptTcpClient();
Debug.Log("Connected");
}
}
// Update is called once per frame
void Update()
{
if (client == null)
{
if (listener.Pending())
{
client = listener.AcceptTcpClient();
Debug.Log("Connected");
}
else
{
return;
}
}
ns = client.GetStream();
if ((ns != null) && (ns.DataAvailable))
{
StreamReader reader = new StreamReader(ns);
msg = reader.ReadToEnd();
float data = float.Parse(msg, CultureInfo.InvariantCulture);
Debug.Log(data);
}
}
private void OnApplicationQuit()
{
if (listener != null)
listener.Stop();
}
}
Python Script
import socket
import struct
import numpy as np
class comm(object):
TCP_IP = '127.0.0.1'
TCP_PORT = 55000
BUFFER_SIZE = 12 # Normally 1024, but we want fast response
conn = []
addr = []
s = []
def connect(self):
self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.s.bind((self.TCP_IP, self.TCP_PORT))
self.s.listen(1)
self.conn, self.addr = self.s.accept()
print ('Connection address:', self.addr)
def receive(self):
byte_data = self.conn.recv(self.BUFFER_SIZE)
pos_data = np.array(np.frombuffer(byte_data, dtype=np.float32));
#print("bytes data:", byte_data)
print ("received data:", pos_data)
#conn.close()
return(pos_data)
def send(self):
cable_length = 25.123
MESSAGE = str(cable_length)
#MESSAGE = cable_length.tobytes()
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((self.TCP_IP, self.TCP_PORT))
#s.send(MESSAGE)
s.send(MESSAGE.encode())
s.close()
return(MESSAGE)
So in order to send data from Unity to Python, I attach the TCPSendPipe.cs to the scene and within python script I just call receive after connecting.
comm_cl = comm()
comm_cl.connect()
while True:
data = comm_cl.receive()
Whereas to send data from Python to Unity, I have to detach TCPSendPipe.cs and attach TCPListenPipe.cs to the scene and within python script I just call send (without connect since connect has socket.bind).
send_data = aa.send()
My purpose is to have a 2 way communication between Unity and Python.
Can I use 2 different sockets to send and receive?, Is it even possible to create and connect to 2 different sockets at the same time?
Any suggestions or ideas on achieveing this is greatly appreciated.
Thank You.
Can I use 2 different sockets to send and receive?, Is it even possible to create and connect to 2 different sockets at the same time?
I'm trying to send an image from C# to Python side via UDP. I split the image by 1024 bytes and send those chunks. On the Python side - I accept and merge them. The problem is speed. The image, which weighs about 200 KB, takes about 7 seconds to send. I read some questions about similar problems with UDP, but nothing helps. What can I do to speed up this connection? Thanks!
The sample image:
Python side:
import time
import threading
import socket
import traceback
import warnings
class ListenPort:
def __init__(self, port: int, is_camera: bool = False):
self.__port = port
self.__is_camera = is_camera
self.thread = None
self.__stop_thread = False
self.out_string = ""
self.out_bytes = b""
self.ip_end_point = ('127.0.0.1', self.__port)
self.sct = None
def start_listening(self):
self.thread = threading.Thread(target=self.listening, args=())
self.thread.start()
def listening(self):
self.sct = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
print("connected: " + str(self.__port))
while not self.__stop_thread:
try:
if self.__is_camera:
self.sct.sendto("Wait for size".encode('utf-16-le'), self.ip_end_point)
image_size, _ = self.sct.recvfrom(4)
print(len(image_size))
if len(image_size) < 4:
continue
buffer_size = (image_size[3] & 0xff) << 24 | (image_size[2] & 0xff) << 16 | \
(image_size[1] & 0xff) << 8 | (image_size[0] & 0xff)
self.sct.sendto("Wait for image".encode('utf-16-le'), self.ip_end_point)
local_bytes = b""
check_iters = 0
for i in range(0, buffer_size // 1024):
local_bytes += self.sct.recvfrom(1024)[0]
self.sct.sendto("Got data".encode('utf-16-le'), self.ip_end_point)
check_iters += 1
print(check_iters)
print(check_iters)
if buffer_size % 1024 > 0:
local_bytes += self.sct.recvfrom(buffer_size % 1024)[0]
self.out_bytes = local_bytes
else:
self.sct.sendto("Wait for data".encode('utf-16-le'), self.ip_end_point)
self.out_bytes, _ = self.sct.recvfrom(1024)
self.out_string = self.out_bytes.decode('utf-16-le')
except OSError:
break
except (Exception, EOFError):
traceback.print_exc()
print("disconnected: " + str(self.__port))
def reset_out(self):
self.out_string = ""
self.out_bytes = b""
def stop_listening(self):
self.__stop_thread = True
self.reset_out()
if self.sct is not None:
self.sct.shutdown(socket.SHUT_RDWR)
if self.thread is not None:
st_time = time.time()
while self.thread.is_alive():
if time.time() - st_time > 2:
warnings.warn("Something went wrong. Rude disconnection on port " + str(self.__port))
self.sct.close()
st_time = time.time()
listen = ListenPort(63213, True)
listen.start_listening()
st_time = time.time()
while True:
if len(listen.out_bytes) == 218669:
print("got image")
break
print(time.time() - st_time)
listen.stop_listening()
# the out of print(time.time() - st_time) is 7.35678505897522
C# side:
public struct Received
{
public IPEndPoint Sender;
public string Message;
}
public abstract class UdpBase
{
protected UdpClient Client;
protected UdpBase()
{
Client = new UdpClient();
}
public async Task<Received> Receive()
{
var result = await Client.ReceiveAsync();
return new Received()
{
Message = Encoding.Unicode.GetString(result.Buffer, 0, result.Buffer.Length),
Sender = result.RemoteEndPoint
};
}
}
public class TalkPortUdp : UdpBase
{
private bool stopTask = false;
private IPEndPoint _talkOn;
private string outString = "";
private byte[] outBytes = new byte[10];
public IPEndPoint sender;
public Task task;
public TalkPortUdp(IPEndPoint endpoint)
{
_talkOn = endpoint;
}
public void SetString(string data)
{
outString = data;
}
public void SetBytes(byte[] data)
{
outBytes = data;
}
public void Send(string message, IPEndPoint endpoint)
{
var datagram = Encoding.Unicode.GetBytes(message);
Client.Send(datagram, datagram.Length, endpoint);
}
public void SendBytes(byte[] message, IPEndPoint endpoint)
{
Client.Send(message, message.Length, endpoint);
}
public void StartTalking()
{
Client = new UdpClient(_talkOn);
stopTask = false;
task = Task.Run(() => {
while (!stopTask)
{
try
{
if (this.Client.Available > 0)
{
var received = this.Receive().GetAwaiter().GetResult();
string clientTask = received.Message;
sender = received.Sender;
if (clientTask.Contains("Wait for size"))
{
byte[] intBytes = BitConverter.GetBytes(outBytes.Length);
this.SendBytes(intBytes, received.Sender);
}
else if (clientTask.Contains("Wait for image"))
{
for (int i = 0; i < outBytes.Length - 1024; i += 1024)
{
byte[] second = new byte[1024];
Buffer.BlockCopy(outBytes, i, second, 0, 1024);
Console.WriteLine(i);
this.SendBytes(second, received.Sender);
received = this.Receive().GetAwaiter().GetResult();
}
int lastt = outBytes.Length % 1024;
if (lastt > 0)
{
byte[] lasttBytes = new byte[lastt];
Buffer.BlockCopy(outBytes, outBytes.Length - lastt, lasttBytes, 0, lastt);
this.SendBytes(lasttBytes, received.Sender);
}
}
else if (clientTask.Contains("Wait for data"))
{
this.Send(outString, received.Sender);
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
Console.WriteLine("Stopped");
});
}
public bool IsAlive()
{
if (task != null)
return task.Status.Equals(TaskStatus.Running);
return false;
}
public void StopTalking()
{
stopTask = true;
Client.Dispose();
Client.Close();
}
}
internal class Program
{
static void Main(string[] args)
{
IPEndPoint ipPoint = new IPEndPoint(IPAddress.Any, 63213);
TalkPortUdp talk = new TalkPortUdp(ipPoint);
talk.StartTalking();
while (true)
{
// Load file meta data with FileInfo
FileInfo fileInfo = new FileInfo(#"D:\Downloads\test_img.png");
// The byte[] to save the data in
byte[] data = new byte[fileInfo.Length];
// Console.WriteLine(fileInfo.Length);
// Load a filestream and put its content into the byte[]
using (FileStream fs = fileInfo.OpenRead())
{
fs.Read(data, 0, data.Length);
}
talk.SetBytes(data);
Thread.Sleep(1000);
}
}
}
I am unable to establish a websocket connection. I use an esp32 as an Client and an Tornado Webserver as Host.
I can connect to the Host with Javascript, but I can also connect the esp32 to websocket.org.
Only the connection between the esp32 and the Tornado Server doesn't work.
ESP32 Code (Arduino IDE):
#include <WiFi.h>
#include <WebSocketClient.h> //By Markus Sattler
const char* ssid = "hadome";
const char* password = "12345678";
char path[] = "/ws";
char host[] = "192.168.178.29";
WebSocketClient webSocketClient;
WiFiClient client;
void setup() {
Serial.begin(115200);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connected");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
delay(5000);
if (client.connect(host, 3333)) {
Serial.println("Connected");
} else {
Serial.println("Connection failed.");
}
webSocketClient.path = path;
webSocketClient.host = host;
if (webSocketClient.handshake(client)) {
Serial.println("Handshake successful");
} else {
Serial.println("Handshake failed.");
}
}
void loop() {
String data;
if (client.connected()) {
webSocketClient.sendData("Info to be echoed back");
webSocketClient.getData(data);
if (data.length() > 0) {
Serial.print("Received data: ");
Serial.println(data);
}
} else {
Serial.println("Client disconnected.");
}
delay(3000);
}
Python Code Excerpt (Tornado):
class WSHandler(tornado.websocket.WebSocketHandler):
def check_origin(self, origin):
return True
def open(self):
pass
def on_message(self, message):
self.write_message(message)
def on_close(self):
log('[WS] Connection was closed.')
application = tornado.web.Application([(r'/ws', WSHandler)])
# Main program logic follows:
if __name__ == '__main__':
# Tornado Server
try:
http_server = tornado.httpserver.HTTPServer(application)
http_server.listen(3333)
http_client = tornado.httpclient.AsyncHTTPClient()
http_client.initialize(1)
log("Tornado Server started")
tornado.ioloop.IOLoop.current().spawn_callback(loop)
tornado.ioloop.IOLoop.instance().start()
except:
log("Exception triggered - Tornado Server stopped.")
finally:
pass
The ESP32 Program outputs:
.......
WiFi connected
IP address:
192.168.2.8
Connected
Waiting...
Handshake failed.
I am very confused because this javascript program works flawlessly (https://www.mischianti.org/2020/12/07/websocket-on-arduino-esp8266-and-esp32-client-1/):
var wsUri = "ws://192.168.178.29:3333/ws";
var output;
function init() {
output = document.getElementById("output");
testWebSocket();
}
function testWebSocket() {
websocket = new WebSocket(wsUri);
websocket.onopen = function (evt) {
onOpen(evt)
};
websocket.onclose = function (evt) {
onClose(evt)
};
websocket.onmessage = function (evt) {
onMessage(evt)
};
websocket.onerror = function (evt) {
onError(evt)
};
}
Sincerely Hannes
PS: Sorry for my bad english
I solved the problem by using another library. (I use the Library of Markus Sattler)
I'm doing project with beacon.
smartphone(android client) collect rssi nearby beacons and send to python(server)
< current application's function >
-> when new beacon signal captured, display beacon's rssi value, Mac address
-> connect with tcp and send to python server in real time (Problem!!)
when using method(send text message to python server) with buttonclickevent,
connecting and sending text message works well.
but when i use method with listview adapter(using ArrayMap),
connecting works well, but can't send rssi.
more detail, infinite loop for waiting data
I think there is a problem between using runOnUiThread and data sending but i'm not sure about it.
Mainactivity
package midascon.example.scanlist;
import com.hanvitsi.midascon.Beacon;
import com.hanvitsi.midascon.BeaconCallback;
import com.hanvitsi.midascon.MidasApplication;
import com.hanvitsi.midascon.manager.ContextManager;
import android.Manifest;
import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.os.StrictMode;
import android.support.v4.app.ActivityCompat;
import android.support.v4.content.ContextCompat;
import android.util.Log;
import android.widget.ListView;
public class MainActivity extends Activity implements BeaconCallback, Runnable
{
private static final int MY_PERMISSIONS_REQUEST_ACCESS_FINE_LOCATION = 100;
private ContextManager contextManager;
private BeaconListAdapter adapter;
#Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
if (android.os.Build.VERSION.SDK_INT > 9) { StrictMode.ThreadPolicy policy = new StrictMode.ThreadPolicy.Builder().permitAll().build(); StrictMode.setThreadPolicy(policy); }
checkPermission();
contextManager = getMidasApplication().getContextManager();
contextManager.getBeaconSettings().setMidasScanMode(false);
adapter = new BeaconListAdapter(getBaseContext()); // Beacon list adapter
ListView listView = (ListView) findViewById(R.id.listView);
listView.setAdapter(adapter);
}
#Override
public void onBeaconCallback(int status, Beacon beacon) // add beacon to list when beacon signal captured
{
switch (status) {
case STATUS_CODE_ENTER:
case STATUS_CODE_UPDATE:
if (adapter != null)
adapter.addBeacon(beacon);
break;
case STATUS_CODE_EXIT:
if (adapter != null)
adapter.removeBeacon(beacon);
break;
default:
break;
}
runOnUiThread(this);
}
public void checkPermission() // allow permission
{
if(checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED){
ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, 1);
}
}
#Override
public void run() {
if (adapter != null)
adapter.notifyDataSetChanged();
}
// call name class setting by AndroidManifest.xml
public MidasApplication getMidasApplication() {
return (MidasApplication) getApplication();
}
#Override
protected void onResume() {
super.onResume();
if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.ACCESS_FINE_LOCATION)) {
ActivityCompat.requestPermissions(this, new String[] { Manifest.permission.ACCESS_FINE_LOCATION }, MY_PERMISSIONS_REQUEST_ACCESS_FINE_LOCATION);
}
else
{
ActivityCompat.requestPermissions(this, new String[] { Manifest.permission.ACCESS_FINE_LOCATION }, MY_PERMISSIONS_REQUEST_ACCESS_FINE_LOCATION);
}
}
else {
if (BluetoothAdapter.getDefaultAdapter().isEnabled()) {
// register callback
contextManager.setBeaconCallback(this);
contextManager.startLeScan();
} else {
contextManager.stopLeScan();
Intent settingsIntent = new Intent(android.provider.Settings.ACTION_BLUETOOTH_SETTINGS);
startActivity(settingsIntent);
}
}
}
#Override
protected void onPause() {
super.onPause();
contextManager.stopLeScan();
}
}
midas is company that made beacon
BeaconListAdapter
public class BeaconListAdapter extends BaseAdapter
{
private final LayoutInflater inflater;
private int count; //counting beacon
private final ArrayMap<String, Beacon> itemMap = new ArrayMap<String, Beacon>();
private final int padding;
public int CurBeaconHave = 2;
private Handler mHandler;
public int port = 9999;
public int initcnt = 0;
public int stackcnt = 0;
public int serveractivate = 0;
public int praccnt = 0;
public static String Sendrssi = "";
public Socket socket = null;
public BeaconListAdapter(Context context) {
super();
padding = (int) context.getResources().getDimension(R.dimen.activity_vertical_margin);
this.inflater = LayoutInflater.from(context);
}
public int addBeacon(Beacon beacon) {
synchronized (itemMap) {
itemMap.put(beacon.getMac(), beacon);
count = itemMap.size();
return count;
}
}
public int removeBeacon(Beacon beacon) {
synchronized (itemMap) {
itemMap.remove(beacon.getMac());
count = itemMap.size();
return count;
}
}
#Override
public int getCount() {
return count;
}
#Override
public Beacon getItem(int position) {
synchronized (itemMap) {
return itemMap.valueAt(position);
}
}
void ToPython() {
try {
String tmp = Sendrssi;
PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())));
out.println(tmp);
out.flush();
Log.d("sendrssi ",tmp);
}
catch (Exception e) {
e.printStackTrace();
}
}
/*public void ToPython() {
try {
String tmp = Sendrssi;
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
out.write(tmp);
out.newLine();
out.flush();
Log.d("Sending. Rssi : ", tmp);
} catch (Exception e) {
e.printStackTrace();
}
}*/
void connect() {
Log.w("state", "connecting..");
Thread checkUpdate = new Thread() {
public void run() {
String newip = "192.168.0.4";
try {
socket = new Socket(newip, port);
Log.w("state ", "server connected");
serveractivate = 1;
} catch (IOException e1) {
Log.w("state ", "failed");
e1.printStackTrace();
System.out.println("error :" + e1.getMessage());
}
}
};
checkUpdate.start();
}
#Override
public long getItemId(int position) {
return position;
}
public void stopsocket()
{
try
{
socket.close();
} catch (IOException e){
e.printStackTrace();
}
}
#Override
public View getView(int position, View convertView, ViewGroup parent) {
TextView textView = null;
if (convertView == null)
{
convertView = inflater.inflate(android.R.layout.simple_list_item_1, parent, false);
textView = (TextView) convertView.findViewById(android.R.id.text1);
textView.setBackgroundColor(Color.WHITE);
textView.setTextColor(Color.BLACK);
textView.setPadding(padding, padding, padding, padding);
convertView.setTag(textView);
}
else
{
textView = (TextView) convertView.getTag();
}
Beacon item = getItem(position);
int temprssi = item.getRssi();
while(serveractivate == 0)
{
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
Log.d("Connect State : ","wait for Server Connect...");
connect();
}
if(serveractivate == 1)
{
try {
socket.setTcpNoDelay(true);
} catch (SocketException e) {
e.printStackTrace();
}
}
int[] values = BeaconUtils.getAccelerometer(item);
textView.setText(String.format("[%s]\nMAC : %s\nRssi : %d\n", item.getType() == Beacon.TYPE_MIDAS ? "Midascon" : "Beacon", item.getMac(),temprssi));
if(count == CurBeaconHave)
{
if(stackcnt == CurBeaconHave)
{
ToPython();
stackcnt = 0;
Sendrssi = "";
}
else if(stackcnt != CurBeaconHave)
{
Sendrssi = Sendrssi + temprssi + " " ;//+ (temprssi - 3) + " " + (temprssi + 5) + " " + (temprssi - 7) + " ";
stackcnt++;
}
}
return convertView;
}
}
total code line is about 400 line, so i upload code that have problem i think.
thank you for reading and try to solve my problem
if you need another code i'll upload it
Note that i'm not good at english, so you may have difficult with reading and understand. sorry for that :(
problem solved.
It's not a normal method, so please be patient.
BeaconListadapter in connect method, i use thread.
but i don't use thread in Topython method.
because of this, there's problem with socket information when send data
so i delete thread in connect method and run and method
in main thread(i know this is idiot thing)
if you use like me, probably use connect and send data method in one thread
I have got PTZ controller, Wemos D1 Mini (based on ESP8266-12F) and Raspberry and I want read data from PTZ using Wemos and send it via wifi to Raspberry. This is my code on RPi:
import socket
s = socket.socket()
# host = socket.gethostname()
host = '192.168.0.26'
port = 9999
s.connect((host, port))
try:
while True:
response1 = s.recv(1024).decode("utf-8")
print(response1)
except KeyboardInterrupt:
s.close()
And my code on Wemos:
#include "ESP8266WiFi.h"
int msg = 0;
String str = String(0,HEX);
bool startReading = false;
String command = "";
const char *ssid = "MyName";
const char *password = "MyPassword";
WiFiServer wifiServer(9999);
void setup() {
Serial.begin(9600);
Serial.setDebugOutput(true);
for(uint8_t t = 4; t > 0; t--) {
Serial.printf("[SETUP] BOOT WAIT %d...\n", t);
Serial.flush();
delay(1000);
}
delay(1000);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(1000);
Serial.println("Connecting..");
}
Serial.print("Connected to WiFi. IP:");
Serial.println(WiFi.localIP());
wifiServer.begin();
}
void loop() {
WiFiClient client = wifiServer.available();
if (client) {
while (client.connected()) {
msg = Serial.read();
if (msg != -1) {
command = String(msg,HEX);
client.print(command);
}
delay(1);
}
client.stop();
Serial.println("Client disconnected");
}
}
Everything work fine, reaading data from PTZ is immediate but sending data to RPi is slow, I can see significant delay. Reducing the distance from the router does not improve the situation. I tried use #include <WebSocketsServer.h> but this libary is even worse. My question is how I can increase communication speed? Will putting the server on rpi instead of wemos help? Are there any more suitable libraries that I could use?