KR20200065655A - Microgrid energy transaction based on cloud - Google Patents

Abstract

The present invention relates to small energy transaction based on cloud to enable optimal peer to peer (P2P) transaction by matching a prosumer and a consumer in real time through a power trading platform based on blockchain. The small energy transaction based on cloud may enable to sell the remaining energy after using produced energy to electric power market, an electricity provider, and other consumers.

Description

MICROGRID ENERGY TRANSACTION BASED ON CLOUD}

The present invention relates to cloud-based small-scale energy trading.

A small-scale prosumer electricity trading program is a transaction that allows electricity to be generated and used and the remaining energy to be sold to the electricity market, electricity suppliers, and other consumers.

The purpose is to make it possible to generate and use power and sell the remaining energy to the power market, electricity vendors, and other consumers.

A cloud-based small-scale energy transaction that enables optimal peer-to-peer (P2P) transactions by matching the optimal prosumers and consumers in real time through a blockchain-based power trading platform.

It will be possible to generate and use the electricity and sell the remaining energy to the electricity market, electricity vendors and other consumers.

Figure 1. Block diagram for small cloud-based energy trading.
Figure 2. Blockchain creation process through energy transaction auction.
Figure 4. Use of GET, POST, and PUT used in app.route().
Figure 5. Status code of the return value.

I. Introduction

A small-scale prosumer power trading program is a transaction that allows electricity to be generated and used and the remaining energy to be sold to the electricity market, electricity sales companies, and other consumers. Match consumers and enable peer-to-peer (P2P) transactions. In the decentralized energy trading and supply system, trading (prosumer-consumer matching) is performed either fully automatically or manually based on smart contracts. Each transaction follows a tamper-proof method, which is recorded on the blockchain. After the transaction is completed, energy is transferred through the network.

Blockchain is a technology that enables so-called "peer-to-peer (P2P)" when applied to the field of energy trading. For trading, any participant in the network can trade directly with any participant in the network without a third party intermediary.

√ For trading, the general blockchain works as follows.

1. If the supplier and the customer agree to enter into a direct transaction, they become the seller and the buyer related to the transaction and determine the variables of this transaction by specifying the sender and size. (All transactions are based on intelligent contracts based on pre-defined individual rules such as quality, price, quantity, etc.)

2. All information related to an individual transaction is combined with details of other transactions made during the same period to create a new data block. (All transaction data is stored on a distributed blockchain, and all relevant information is stored identically on all participants' computers)

3. Blockchain is different in that this process involves a single standardized transaction.

4. Each transaction is encrypted and distributed to many individual computers (peer-to-peer), with each computer storing data locally. (Most automated decentralized transaction models that do not require third-party intermediaries.)

5. Network members automatically check transactions stored on individual computers.

√ Blockchain operation sequence for energy trading. (Figure 1)

1. Prosumers and consumers request a transaction and agree to the transaction if the transaction conditions are met.

2. The requested transaction is combined with other transactions made during the same period to create a block and broadcast to a peer-to-peer network of computers known as nodes.

3. The global network uses algorithms to verify transaction and user status. Verified transactions may include cryptocurrency, contracts, records or other information.

4. The verified block is combined with all other previously verified transactions to create a new data block for the ledger. This means that the block is constantly increasing.

5. Then the new block is added to the existing blockchain in a permanent and immutable way

6. Transaction completed

√ For energy trading, verification goes through the following steps.

1. Individual transactions are combined to form a block.

2. If there is a correct combination, check the data contained in each block using an algorithm that generates a hash.

3. Newly created blocks are added to the end of the ever-increasing blockchain.

4. Data stored in each blockchain (which spans all blocks) is also continuously verified.

II. Creating a matching blockchain between traders for energy trading

In the blockchain, blocks are chained as a hash value, and each block contains a plurality of information. The blocks are sorted by time and each block is connected to the previous block. If one block is changed, the contents of the other block are also changed. Therefore, as the chain lengthens, the reliability of the block increases. Data that can be entered into each block may be variously included according to purposes such as trade transaction information and energy use information as well as financial transaction information.

In this study, we implement a blockchain for power transactions. For this transaction, auction algorithm is performed between prosumers. The auction algorithm assumes that the seller sets an auction time and an auction occurs within that time. The optimal trading criterion assumes that the trade between the consumer and the prosumer who presented the highest value at a given time. 2 shows a process of creating a blockchain through auctioning energy transactions.

Matching through auction goes through the following steps

1. Prosumer's surplus power for sale and consumer's demand power are determined and presented to the market

2. Perform matching algorithm between prosumer and consumer based on the power of the transaction proposed by the energy network controlled by the contract

3. Signing a smart contract based on the determined transaction me

III. Blockchain class using UML

The UMT (Unified Modeling Language) notation was used for the representation of the class template and object in FIG. 3. The class diagram is independent of the programming language, but was implemented using Python in this study.

3.1 Constructor BlockChain()

When creating, initialize the following variables.

chain: Initializes the list variable to contain all blocks.

Transactions: This is a list variable for storing energy transactions in a block.

create_block(Nonce = 1, PreviousHash = '0'): Create a Genesis block when a node is newly created.

nodes: No order required, declared as a set variable to put only addresses, and one address is defined for one node.

3.2 function create_block (Nonce, PreviousHash): block

Create a new block variable of type Dictionary composed as follows.

block: index: Current chain number + 1

CreatedTime: Current time

Hash: Hash value of the current block

Nonce: Nonce value

Previous Hash: The hash value of the previous block

Transactions: Added Transactions list variable containing energy transaction list

After creation, the Hash() function is called to define the hash value of the current block, and the created block is added to the chain variable to connect the blocks.

Reinitialize and reuse the energy transactions (Transactions variables) added to the block.

3.3 Function get_previous_block ():chain

To get the previous block of the current block, the block at the end of the chain is called.

3.4 Function Nonce_of_work(previous_Nonce): new_Nonce

New_Nonce and check_Nonce are declared as proof of work in the block creation phase. Subsequently, the square of New_Nonce is subtracted from the square of Nonce(previous_Nonce) value of the previous block, and the value is converted into sha256 (a 64-digit string composed of 256 bits). Define the value in Hash_operation variable.

If the Hash_operation variable satisfies a specific condition (all four digits of the first string are '0'), new_Nonce is returned.

3.5 Function Hash(block): hash_value

It takes a dictionary type block as an input value. To define the hash value of the block, the data of the block is always sorted in the same format, the encoding process is performed, and it is converted to sha256 and returned.

3.6 Function is_chain_valid(chain):Boolean

The validation of the chain for consensus is to make sure that the blocks that make up the chain are fine. Among all blocks, the check is performed in order from the next block of the Genesis block (the first block). It compares the previous hash value of the previous block with the actual previous block's hash value, and returns False if the values do not match. Then, using the nonce value of the corresponding block and the previous block, the process of proof of work is repeated, and if it does not match the set condition, a false value is returned. If all conditions are met, the next block is checked.

Returns true if all blocks have been successfully inspected.

3.7 functions add_energy_transaction(self, Sender, Receiver, UnitPriceperWatt, Amount, TotalPrice):

This function adds energy transaction data to the Transactions variable.

Energy transaction data = ‘Sender’: prosumer

‘Receiver’: consumer

‘Unitpriceperwatt’: Unit price per watt

‘Amount’: Electricity

'Totalprice': Total price (Amount * Unitpriceperwatt)

The input values received through the flask function are grouped into a Dictionary type and added to the Transactions list variable.

It retrieves the index value of the last block (the end of the chain) and returns the index value of the block added to record how many blocks the current energy transaction is added to.

3.8 Function add_node(self, address):

This is a function for adding a node to the network.

It receives the node's address, parses the address, and adds the node to the network.

http://127.0.0.1:5000/ => Change it to '127.0.0.1:5000' and add it.

3.9 Function replace_energy_chain():Boolean

Every node in the network should always keep the same chain, and it checks which chain is smaller than the longest chain in the network and replaces it.

Define all nodes in the network variable. If the chain of all nodes is valid (is_chain_valid), compare the chain length of each node defined in the network variable with its own chain length, and if there is a chain longer than itself, replace the chain with the longest chain and return True. , If its chain is the longest, it returns False.

IV. Running a web application on Flask

Flask: Flask is a WSGI microframework that provides minimal functionality and allows for very flexible application creation.

app = Flask(__name__): Create an instance of Flask class. Because it is used as a single module or package, __name__ must be used.

from flask import Flask, jsonify, request:

jsonify: This is a JSON utility function in Flask, and is imported to create a JSON-type HTTP Response.

request: Imported to access incoming request data to the library for HTTP communication.

@app.route(): Receives a URL rule and executes the registered function when a request comes in to the URL of the corresponding rule.

4.1 Block creation: mine_energy_block()

This is a function that mines a new block. If the Transactions variable is empty (if no energy transaction has been made), the message'No Transactions entered' is returned. Create a new block and get the block to connect (the last block in the current chain). The proof of work of a newly created block (Nonce) uses the value returned by the Nonce_of_work function by utilizing the value of Nonce of the previous block. Then, create a block with create_block including the hash value of the previous block and the proof value.

response = Index: index value of the current block

CreatedTime: Current time

Nonce: Work proof value of the current block

previous_hash: Hash value of previous block

Hash: Hash value of the current block

Transactions: transactions variable in the current block

return jsonify(response),201: Returns the value of response in JSON format. The status code of the return value is shown in FIG. 5.

4.2 Functions for fetching all blocks: get_chain(), get_value(),

·Get_chain()

This function checks the data value and length of the current chain of the executing node.

response = chain: chain of the current node

length: Number of blocks in the chain

return jsonify(response), returns 200

·Get_value()

This is a function that converts and returns the KEY value of each data in the PHP environment because the data type to be loaded is json.

4.3 Blockchain validation function: is_valid()

It checks whether the chain of the executing node is valid and returns the corresponding message.

Function executed: is_chain_valid()

If the return value is true,'message':'Blockchain is valid.' Store the value in the response variable

If the return value is false, the value of'message':'There is a problem with the current blockchain' is stored in the response variable.

return jsonify(response), returns 200

4.4 Functions for adding energy transactions to the blockchain: add_energy_transaction(), add_energy_transaction_get()

When an energy transaction is made, the data value of the transaction is received in the energy transaction data variable and added to the block.

Energy transaction data = ‘Sender’: Prosumer

‘Receiver’: Consumer

‘Unitpriceperwatt’: Unit price per watt

‘Amount’: Electricity

'Totalprice': Total price (Amount * Unitpriceperwatt)

Function executed: add_energy_transaction()

If any variable used for energy trading has an undefined value,'the value(s) for the transaction is missing. Please check it.' Returns a value of 400.

If all values are defined in the variables used for energy trading, execute the add_energy_transaction() function and'message':'This transaction is added to the block.' + The str(Index) value is declared in the response variable.

return jsonify(response), 201.

4.5 Functions that convert the chain to the initial state: self_init(), all_self_init()

self_init()

This function makes the chain state of the executed node to the initial state.

Function executed: selfinit()

response = chain: chain of the current node

length: Number of blocks in the chain

return jsonify(response), returns 200

all_self_init()

This function initializes the chain of all nodes in the network to the initial state.

Function executed: self_init()

V. How to decentralize the blockchain and make the blocks of all participating nodes the same

5.1 New node connection: connect_node()

It is a function that connects a new node to the node to be executed and configures the network between each node.

Function executed: add_node()

The address value of the new node is entered, and the node is added to the network variable.

If the input value does not exist, "No node", 400 is returned.

If all nodes were processed normally

response ='message':'All nodes are now connected.'

total_nodes: Nodes currently connected to the node

return jsonify(response), 201.

5.2 Replace the chain with the longest chain if necessary: replace_energy_chain()

This function determines the longest node on the network from the node being executed and processes the corresponding task.

Function executed: replace_energy_chain()

If return value is true

response ='message':'The current node is not the same as any other node. Replace it with a valid node's blockchain.'

new_chain: Declares the corresponding value of the replaced chain value in the response.

If return value is false

response ='message':'Blockchain remains valid.'

actual_chain: Declares the corresponding value of your chain value in response.

return jsonify(response), 200 Returns the relevant value.

Claims (1)

A cloud-based small-scale energy transaction that enables optimal peer-to-peer (P2P) transactions by matching the optimal prosumers and consumers in real time through a blockchain-based power trading platform.

Images