IoT Platform

Tárhely és grafikus felület adatainak

---

Hihetelenül egyszerű

A beágyazott fejlesztést példakódok, az oldal használatát alapos dokumentáció és technikai segítség könnyíti meg.

---

Rendkívül gyors

Az adatbázis-kezelésről és a vizuális megjelenítésről mi gondoskodunk, hogy Ön az elektronikai fejlesztésre és ügyfeleire tudjon koncentrálni.

---

Integrálható

Adataiból a rendszer automatikusan XML fájlt generál, amely elérhetővé tehető más ügyviteli szoftver számára.

---

Titkosítható

Adatai nálunk biztonságban vannak. Feltöltheti őket titkosítva is, hogy semmiképp se legyen mások előtt látható.

---

Ingyenesen használható

A regisztráció és a legtöbb funkció időkorlát nélkül ingyenesen használható.

---

FREE
Max number of devices:	1 db
Max data to storage (per device):	100 db
Integrability (XML generate):	YES
Encryption:	YES
Egyedi scriptek:	No
Price:	0 Eur / month 0 Ft / month

PREMIUM
Max number of devices:	10 db
Max data to storage (per device):	10.000 db
Integrability (XML generate):	YES
Encryption:	YES
Egyedi scriptek:	No
Price:	1 Eur / month 390 Ft / month

BUSINESS
Max number of devices:	20 db
Max data to storage (per device):	100.000 db
Integrability (XML generate):	YES
Encryption:	YES
Egyedi scriptek:	YES
Price:	2 Eur / month 790 Ft / month

Otthoni vagy oktatási célokra:

Te is szeretsz otthon forrasztani, mikrovezérlőt programozni, de a webes megjelenítéssel nem szeretnél bajlódni? Nálunk rendkívül egyszerűen megjelenítheted az általad mért adatokat. A robotikát oktatóknak tökéletes választás a diákok hatékony tanításához.

Kis- és középvállalkozásoknak:

Cégednek vagy ügyfeleidnek az az igénye, hogy általad fejlesztett vagy telepített eszközöket bárhonnan elérhessék? Nincs rá elég idő, anyagi keret vagy tudás, hogy megoldjátok? Nálunk egy gyorsan beállítható és megfizethető megoldást találtok.

                
/*
 * ESP32 code example
 */
#include <WiFi.h>

const char* ssid = "your-wifiname";
const char* password = "your-wifipassword";
const char* host = "iot.torocsiktech.hu";
const char* url = "/upload/your-username/your-devicename/";
const int httpPort = 80;

void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
  WiFi.begin(ssid, password);
  for(int i=0; (i<20)&&(WiFi.status() != WL_CONNECTED); i++) {
    delay(500);
    Serial.print(".");
  }
  if(WiFi.status() != WL_CONNECTED) Serial.println("Connection failed");
  if(WiFi.status() == WL_CONNECTED) Serial.println("WiFi connected");
}

void loop() {
  // put your main code here, to run repeatedly:
  WiFiClient client;
  int counter = 0;
  for(int i=0; (i<20)&& (!client.connect(host, httpPort)); i++) {
    delay(500);
    Serial.print(".");
  }
  if(!client.connect(host, httpPort)) Serial.println("Connection failed");
  if(client.connect(host, httpPort)) Serial.println("Host connected");
  delay(10000);
  String content = "{\"myKey1\": 0.12, \"myKey2\": 1.2, \"myKey3\": 12.0 }";
  client.print(String("POST ") + url + " HTTP/1.1\r\n" +
               "Host: " + host + "\r\n" +
               "Content-Length: " + String(content.length(), DEC) + "\r\n" +
               "\r\n" +
               content +
               "\r\n");
  while(client.available()) {
    String response = client.readStringUntil('\r');
    Serial.println(response);
  }
}
                
            

                
/* 
 * STM32 example code
 * 
 * 1. Open your .ioc file and set up ETH and LWIP */
 * 2. Create the "tcpClientRAW.c" and "tcpClientRAW.h" file
 * 3. Copy the following codes to the right place
 */

/* -------------------- tcpClientRAW.c -------------------- */

#include "tcpClientRAW.h"
#include "lwip/tcp.h"
#include "string.h"
enum tcp_client_states {
	ES_NONE = 0,
	ES_CONNECTED,
	ES_RECEIVING,
	ES_CLOSING
};
struct tcp_client_struct {
	u8_t state;             /* current connection state */
	u8_t retries;
	struct tcp_pcb *pcb;    /* pointer on the current tcp_pcb */
	struct pbuf *p;         /* pointer on the received/to be transmitted pbuf */
};
static err_t tcp_client_connected(void *arg, struct tcp_pcb *tpcb, err_t err); /* This callback will be called, when the client is connected to the server */
static err_t tcp_client_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err); /* This callback will be called, when the client receive data from the server */
static err_t tcp_client_poll(void *arg, struct tcp_pcb *tpcb); /* This callback will be called, when the server Polls for the Client */
static err_t tcp_client_sent(void *arg, struct tcp_pcb *tpcb, u16_t len);/* This callback will be called, when the server acknowledges the data sent by the client */
static void tcp_client_send(struct tcp_pcb *tpcb, struct tcp_client_struct *es); /* A Function to send the data to the server */
static void tcp_client_connection_close(struct tcp_pcb *tpcb, struct tcp_client_struct *es); /* Function to close the connection */
static void tcp_client_handle (struct tcp_pcb *tpcb, struct tcp_client_struct *es);/* This is the part where we are going to handle the incoming data from the server */
struct tcp_client_struct *esTx = 0; /* create a struct to store data */
struct tcp_pcb *pcbTx = 0;
void TCPClient_Transmit(char* buf, int len) {
	if (len !=0) {
		esTx->p = pbuf_alloc(PBUF_TRANSPORT, len , PBUF_POOL); /* allocate pbuf */
		pbuf_take(esTx->p, (char*)buf, len); /* copy data to pbuf */
		tcp_client_send(pcbTx, esTx);
		pbuf_free(esTx->p);
	}
}
void tcp_client_init(int ip1, int ip2, int ip3, int ip4, int port) {
	struct tcp_pcb *tpcb; /* 1. create new tcp pcb */
	tpcb = tcp_new();
	ip_addr_t destIPADDR;
	IP_ADDR4(&destIPADDR, ip1, ip2, ip3, ip4);
	tcp_connect(tpcb, &destIPADDR, port, tcp_client_connected); /* 2. Connect to the server */
}
static err_t tcp_client_connected(void *arg, struct tcp_pcb *newpcb, err_t err) {
	err_t ret_err;
	struct tcp_client_struct *es;
	LWIP_UNUSED_ARG(arg);
	LWIP_UNUSED_ARG(err);
	es = (struct tcp_client_struct *)mem_malloc(sizeof(struct tcp_client_struct)); /* allocate structure es to maintain tcp connection information */
	if (es != NULL) {
		es->state = ES_CONNECTED;
		es->pcb = newpcb;
		es->retries = 0;
		es->p = NULL;
		tcp_arg(newpcb, es); /* pass newly allocated es structure as argument to newpcb */
		tcp_recv(newpcb, tcp_client_recv); /* initialize lwip tcp_recv callback function for newpcb  */
		tcp_poll(newpcb, tcp_client_poll, 0); /* initialize lwip tcp_poll callback function for newpcb */
		tcp_sent(newpcb, tcp_client_sent); /* initialize LwIP tcp_sent callback function */
		tcp_client_handle(newpcb, es); /* handle the TCP data */
		ret_err = ERR_OK;
	} else {
		tcp_client_connection_close(newpcb, es); /*  close tcp connection */
		ret_err = ERR_MEM; /* return memory error */
	} return ret_err;
}
static err_t tcp_client_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err) {
	struct tcp_client_struct *es;
	err_t ret_err;
	LWIP_ASSERT("arg != NULL",arg != NULL);
	es = (struct tcp_client_struct *)arg;
	if (p == NULL) { /* if we receive an empty tcp frame from server => close connection */ 
		es->state = ES_CLOSING; /* remote host closed connection */
		if(es->p == NULL) tcp_client_connection_close(tpcb, es); /* we're done sending, close connection */
		ret_err = ERR_OK;
	} else if(err != ERR_OK) { /* else : a non empty frame was received from server but for some reason err != ERR_OK */ 
		if (p != NULL) { /* free received pbuf*/
			es->p = NULL;
			pbuf_free(p);
		} ret_err = err;
	} else if(es->state == ES_CONNECTED) {
		es->p = p; /* store reference to incoming pbuf (chain) */
		tcp_recved(tpcb, p->tot_len); /* Acknowledge the received data */
		tcp_client_handle(tpcb, es); /* handle the received data */
		pbuf_free(p);
		ret_err = ERR_OK;
	} else if(es->state == ES_CLOSING) {
		tcp_recved(tpcb, p->tot_len); /* odd case, remote side closing twice, trash data */
		es->p = NULL;
		pbuf_free(p);
		ret_err = ERR_OK;
	} else {
		tcp_recved(tpcb, p->tot_len); /* unknown es->state, trash data  */
		es->p = NULL;
		pbuf_free(p);
		ret_err = ERR_OK;
	} return ret_err;
}
static err_t tcp_client_poll(void *arg, struct tcp_pcb *tpcb) {
	err_t ret_err;
	struct tcp_client_struct *es;
	es = (struct tcp_client_struct *)arg;
	if (es != NULL) {
		if (es->p == NULL) {
			if(es->state == ES_CLOSING) tcp_client_connection_close(tpcb, es); /*  close tcp connection */
		} ret_err = ERR_OK;
	} else { /* nothing to be done */
		tcp_abort(tpcb);
		ret_err = ERR_ABRT;
	} return ret_err;
}
static err_t tcp_client_sent(void *arg, struct tcp_pcb *tpcb, u16_t len) {
	struct tcp_client_struct *es;
	LWIP_UNUSED_ARG(len);
	es = (struct tcp_client_struct *)arg;
	es->retries = 0;
	if(es->p == NULL) {
		if(es->state == ES_CLOSING) tcp_client_connection_close(tpcb, es); /* if no more data to send and client closed connection*/
	} return ERR_OK;
}
static void tcp_client_send(struct tcp_pcb *tpcb, struct tcp_client_struct *es) {
	struct pbuf *ptr;
	err_t wr_err = ERR_OK;
	while ((wr_err == ERR_OK) && (es->p != NULL) && (es->p->len <= tcp_sndbuf(tpcb))) {
		ptr = es->p; /* get pointer on pbuf from es structure */
		wr_err = tcp_write(tpcb, ptr->payload, ptr->len, 1); /* enqueue data for transmission */
		if (wr_err == ERR_OK) {
			u16_t plen;
			u8_t freed;
			plen = ptr->len;
			es->p = ptr->next; /* continue with next pbuf in chain (if any) */
			if(es->p != NULL) pbuf_ref(es->p); /* increment reference count for es->p */
			do { /* chop first pbuf from chain */
				freed = pbuf_free(ptr); /* try hard to free pbuf */
			}
			while(freed == 0);
		} else if(wr_err == ERR_MEM) {
			es->p = ptr; /* we are low on memory, try later / harder, defer to poll */
		} else { /* other problem ? */ }
	}
}
static void tcp_client_connection_close(struct tcp_pcb *tpcb, struct tcp_client_struct *es) {
	tcp_arg(tpcb, NULL); /* remove all callbacks */
	tcp_sent(tpcb, NULL);
	tcp_recv(tpcb, NULL);
	tcp_err(tpcb, NULL);
	tcp_poll(tpcb, NULL, 0);
	if (es != NULL) mem_free(es); /* delete es structure */
	tcp_close(tpcb); /* close tcp connection */
}
__weak void TCPClient_Receive(char* buf, unsigned int inIP) {
	TCPClient_Transmit(buf, strlen(buf));
	char tempbuf[32] = " + Hello from Client!\n\0";
	TCPClient_Transmit(tempbuf, strlen(tempbuf));
}
static void tcp_client_handle (struct tcp_pcb *tpcb, struct tcp_client_struct *es) {
	unsigned int inIP = tpcb->remote_ip.addr; /* get the Remote IP */
	esTx = es;
	pcbTx = tpcb;
	char buf[255];
	memset (buf, '\0', 255);
	if(es->p->len > 0 && es->p->len < 255) strncpy(buf, (char *)es->p->payload, es->p->len);
	TCPClient_Receive(buf, inIP);
}

/* -------------------- tcpClientRAW.h -------------------- */

#ifndef INC_TCPCLIENTRAW_H_
#define INC_TCPCLIENTRAW_H_

void tcp_client_init(int ip1, int ip2, int ip3, int ip4, int port);
void TCPClient_Transmit(char* buf, int len);
void TCPClient_Receive(char* buf, unsigned int inIP);

#endif /* INC_TCPCLIENTRAW_H_ */

/* -------------------- main.c (only "USER CODE" sections) -------------------- */

/* USER CODE BEGIN Includes */
#include "tcpClientRAW.h"
/* USER CODE END Includes */

/* USER CODE BEGIN 0 */
struct netif gnetif;
/* USER CODE END 0 */

/* USER CODE BEGIN 2 */
tcp_client_init(185, 51, 191, 54, 80); 
/* iot.torocsiktech.hu domain equals to 185.51.191.54 IP address (and 80 port for HTTP) */
/* make sure that the IP, netmask and gateway (=your router) addresses are correct */
/* USER CODE END 2 */

    /* USER CODE BEGIN 3 */
	  ethernetif_input(&gnetif);
	  sys_check_timeouts();
	  /* Your custom code in main-loop */
	  /* Try to avoid delay() fuction */
	  /* TCPClient_Transmit(char* buf, int len) function is for transmit data to server */
  }
  /* USER CODE END 3 */

/* USER CODE BEGIN 4 */
void TCPClient_Receive(char* buf, unsigned int inIP) {
	/* It is called when data is coming from server */
	/* Your custom code to handle it */
}
/* USER CODE END 4 */