Untitled

import psycopg2

def save_data_to_database(data):
    try:
        # Replace the following with your PostgreSQL database configuration
        dbname = "mydatabase"
        user = "your_username"
        password = "your_password"
        host = "localhost"
        port = "5432"

        connection = psycopg2.connect(
            dbname=dbname, user=user, password=password, host=host, port=port
        )
        cursor = connection.cursor()

        # Replace 'column1_value' and 'column2_value' with your data values
        column1_value = data["column1"]
        column2_value = data["column2"]

        insert_query = f"INSERT INTO mytable (column1, column2) VALUES ('{column1_value}', {column2_value});"
        cursor.execute(insert_query)

        connection.commit()
        cursor.close()
        connection.close()
        print("Data saved to the database successfully.")
    except Exception as e:
        print("Error:", e)

if __name__ == "__main__":
    # Example data to save to the database
    data_to_save = {
        "column1": "Value1",
        "column2": 42
    }

    save_data_to_database(data_to_save)




/////

import bluetooth
import threading

def handle_client(client_socket, client_address):
    print("Connected with", client_address)

    while True:
        data = client_socket.recv(1024)
        if not data:
            break
        print("Received from", client_address, ":", data.decode())

    client_socket.close()
    print("Disconnected from", client_address)

def start_server():
    server_socket = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
    port = 1  # RFCOMM port number, must be the same as the client
    server_socket.bind(("", port))
    server_socket.listen(3)  # Maximum of 3 clients (you can adjust this value)

    print("Waiting for connections...")

    threads = []
    while True:
        client_socket, client_address = server_socket.accept()
        thread = threading.Thread(target=handle_client, args=(client_socket, client_address))
        thread.start()
        threads.append(thread)

    # Wait for all client threads to finish
    for thread in threads:
        thread.join()

    server_socket.close()

if __name__ == "__main__":
    start_server()


///

#include <stdio.h>
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_log.h"
#include "esp_bt.h"
#include "esp_bt_main.h"
#include "esp_gap_bt_api.h"
#include "esp_gattc_api.h"

#define GATTC_TAG "GATTC_DEMO"
#define REMOTE_SERVICE_UUID         0x00001101
#define REMOTE_NOTIFY_CHAR_UUID     0x00001101
#define PROFILE_NUM                 1
#define PROFILE_APP_IDX             0
#define ESP_APP_ID                  0x55
#define ADV_DATA_LEN                31

static const char* TAG = "ESP32_Client";
static esp_gattc_cb_t gattc_cb_param;
static uint8_t notify_data[ADV_DATA_LEN];

static void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t* param) {
    if (event == ESP_GAP_BLE_SCAN_RESULT_EVT) {
        esp_ble_gap_cb_param_t* scan_result = (esp_ble_gap_cb_param_t*)param;
        switch (scan_result->scan_rst.search_evt) {
            case ESP_GAP_SEARCH_INQ_RES_EVT: {
                if (memcmp(scan_result->scan_rst.bda, YOUR_RASPBERRY_PI_MAC_ADDRESS, ESP_BD_ADDR_LEN) == 0) {
                    esp_ble_gap_stop_scanning();
                    esp_ble_gattc_open(gattc_cb_param.reg.app_id, scan_result->scan_rst.bda, scan_result->scan_rst.ble_addr_type, true);
                }
                break;
            }
            case ESP_GAP_SEARCH_INQ_CMPL_EVT: {
                break;
            }
            default:
                break;
        }
    }
}

static void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t* param) {
    switch (event) {
        case ESP_GATTC_REG_EVT:
            esp_ble_gap_start_scanning(10);
            break;
        case ESP_GATTC_OPEN_EVT: {
            if (param->open.status != ESP_GATT_OK) {
                break;
            }
            ESP_LOGI(GATTC_TAG, "Connected to the server.");
            break;
        }
        case ESP_GATTC_DISCONNECT_EVT: {
            ESP_LOGI(GATTC_TAG, "Disconnected from the server.");
            esp_ble_gap_start_scanning(10);
            break;
        }
        default:
            break;
    }
}

static void send_data_task(void* arg) {
    while (1) {
        vTaskDelay(5000 / portTICK_PERIOD_MS); // Send data every 5 seconds

        // Replace the example data with the data you want to send
        const char* dataToSend = "Hello, Raspberry Pi!";
        esp_ble_gattc_send_char_descr_by_uuid(gattc_cb_param.gattc_if,
            gattc_cb_param.conn_id,
            REMOTE_SERVICE_UUID,
            REMOTE_NOTIFY_CHAR_UUID,
            strlen(dataToSend),
            (uint8_t*)dataToSend,
            ESP_GATT_WRITE_TYPE_RSP,
            ESP_GATT_AUTH_REQ_NONE);
    }
}

void app_main() {
    esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
    esp_err_t ret;

    ret = esp_bt_controller_init(&bt_cfg);
    if (ret) {
        ESP_LOGE(TAG, "%s initialize controller failed: %s\n", __func__, esp_err_to_name(ret));
        return;
    }

    ret = esp_bt_controller_enable(ESP_BT_MODE_BLE);
    if (ret) {
        ESP_LOGE(TAG, "%s enable controller failed: %s\n", __func__, esp_err_to_name(ret));
        return;
    }

    ret = esp_bluedroid_init();
    if (ret) {
        ESP_LOGE(TAG, "%s initialize bluedroid failed: %s\n", __func__, esp_err_to_name(ret));
        return;
    }

    ret = esp_bluedroid_enable();
    if (ret) {
        ESP_LOGE(TAG, "%s enable bluedroid failed: %s\n", __func__, esp_err_to_name(ret));
        return;
    }

    esp_ble_gap_register_callback(gap_event_handler);
    esp_ble_gattc_register_callback(gattc_event_handler);

    esp_err_t local_mtu_ret = esp_ble_gatt_set_local_mtu(500);
    if (local_mtu_ret) {
        ESP_LOGE(GATTC_TAG, "set local  MTU failed, error code = %x", local_mtu_ret);
    }

    ret = esp_ble_gattc_app_register(ESP_APP_ID);
    if (ret) {
        ESP_LOGE(GATTC_TAG, "gattc app register error, error code = %x", ret);
        return;
    }

    xTaskCreate(send_data_task, "send_data_task", 2048, NULL, 5, NULL);
}