Inspiration
The inspiration for the "Decentralized Autonomous Vehicles" (DAV) project stems from the growing advancements in autonomous vehicle technology and the potential benefits it can bring to transportation systems worldwide. The vision of a future where self-driving vehicles are seamlessly integrated into our daily lives sparked the idea to leverage blockchain technology to enhance their capabilities.
The inspiration also arose from recognizing the challenges that autonomous vehicles face when making real-time decisions in complex and dynamic environments. Factors like unpredictable weather conditions, traffic patterns, and road hazards can pose risks and require immediate adaptive responses. By implementing a decentralized network and leveraging the transparency and security features of blockchain, we aim to create a system where vehicles can share and learn from each other's experiences, ultimately improving decision-making and enhancing safety on the roads.
Furthermore, the concept of a decentralized network aligns with the core principles of blockchain technology, such as transparency, immutability, and security. By harnessing these properties, we seek to create an infrastructure that fosters collaboration, data sharing, and collective learning among autonomous vehicles. The decentralized nature of the DAV project also addresses concerns related to data privacy, security, and centralized control by empowering vehicles to make informed decisions while maintaining data integrity and protecting against unauthorized access.
Ultimately, the inspiration for the DAV project arises from the desire to build a future where autonomous vehicles operate in a decentralized and secure manner, leveraging the power of blockchain to enhance decision-making, improve safety, and create a more efficient and sustainable transportation ecosystem.
What it does
Decentralized Autonomous Vehicles is a network that will ultimately connect self-driving vehicles (such as cars, trucks, and drones etc..) to every vehicle on the Blockchain network, enabling them to make secure real-time decision making. By implementing decentralized nature from the blockchain we are enabling decentralized decision-making when there exist some environmental factors such as bad weather conditions, bad road conditions, traffic patterns etc., Once the vehicle will experience an incident and learns something from it, then the data learned from incident will be added to the ledger and made available to all other nodes in the network shared ledger so that other vehicles can make decisions based on the data provided. So that, all the vehicles connected to that decentralized shared ledger can learn automatically and make decisions from the experience of every single vehicle. A decentralized network connecting autonomous vehicles on the blockchain using Vehicular IoT (VIoT) and Vehicular Ad-hoc Network (VANET) technology. The system guarantees data security and privacy, transparency, traceability, and protection against unauthorized access or data tampering/destruction
How we built it
1 Created VIoT Vehicular IoT (VIoT) refers to the network of IoT devices and sensors installed in a self-driving car that collect and exchange data about the vehicle’s environment and performance.
1.1 Created Map(net) [nod +edg +type] The creation of the Map(net) in SUMO involves defining the topology of the road network, which is comprised of nodes and edges. Nodes are points in the network where edges connect, and edges represent the connections between nodes, or in other words, the road segments. To create the Map(net), you will need to define the nodes, edges, and types
Nodes: Nodes are defined using the tag and require an identifier as well as the X and Y coordinates of the node on the map. we have defined 15 nodes such as n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11, n12, n13, n14, and n15 in Sumo, and saved this node information in a file with an extension of .nod.xml. The file is named Points.nod.xml.
Edges: Edges are defined using the tag and require an identifier, as well as the identifiers of the nodes that the edge connects. You can also specify the type of the edge, the number of lanes, and other parameters. We have defined the edges between nodes in our simulation, including connections such as n1n2, n2n3, n3n4, n5n6, n2n7, n7n8, n8n9, n9n10, n10n4, n2n11, n11n12, n12n13, n13n14, n14n5, n9n3, n3n12, and n14n15. These edges help to define the possible routes that the VIoT vehicles can take and allow us to simulate traffic flow in the network. The edge information is saved in a file with an extension of .edg.xml. The file is named Paths.edg.xml.
Types: Types are defined using the tag and represent the different types of edges in the network. You can specify parameters such as the number of lanes, the speed limit, and the priority. The two different types of edge types, 2L30 and 2L75, have been defined in the simulation, each with their own speed limit. These speed limits are used to calculate the time it takes for a vehicle to traverse the edge and can be used to determine the optimal route for the vehicle. The type information is saved in a file with an extension of .types.xml. The file is named as Types.type.xml. Once you have created the nod.xml, types.xml, and edg.xml files that define the nodes, edges, and types of your road network, you can use the netconvert tool to convert them into a .net.xml file that SUMO can use to simulate the network. To do this, follow these steps:
• Open the command prompt or terminal and navigate to the directory where your nod.xml, types.xml, and edg.xml files are saved.
• Run the netconvert command and specify the names of the three input files, as well as the name of the output file (which will be the .net.xml file).
netconvert --node-files Points.nod.xml --edge-files Paths.edg.xml -t Types.type.xml -o Map.net.xml
• Once netconvert has finished, you should see a new file in your directory named "Map.net.xml". This is Map(net) file that we can use to simulate road network in SUMO.
1.2 Created Route (rou)
• In order to simulate vehicles on your road network, you need to define the routes that they will take. A route is simply a sequence of edges that the vehicle follows from its origin to its destination.
• Routes are defined using the tag. A route needs an identifier and a list of edges, which represents the path that the vehicle will follow. The edges are specified using the 'edges' attribute of the tag.
• We have carefully defined four distinct routes for our vehicles in Sumo simulation. For instance, veh0 follows the route0 that passes through n1n2, n2n3, n3n4, n4n5, and n5n6 edges. Similarly, veh1 takes the route1, which includes n1n2, n2n7, n7n8, n8n9, n9n10, n10n4, n4n5, and n5n6 edges. Veh2 follows the route2, which covers n1n2, n2n11, n11n12, n12n13, n13n14, n14n5, and n5n6 edges. Finally, veh3 takes the route3 that passes through n1n2, n2n3, n3n4, n4n5, and n5n6 edges. However, we have also encountered some obstacles on our way that we have defined in the n2n3 and n9n10 edges, which we need to overcome using smart contract functions to update the routes of the VIoT vehicles on the blockchain.
• Once you have defined your routes, you need to save them as .rou.xml files. You can create as many route files as you need, with each file containing one or more routes. We have saved the file as Route.rou.xml.
• Once you have defined your routes and saved them as .rou.xml files, you can use them in your SUMO simulations by specifying them as input to the simulation.
1.3 Created Sumo configuration [Map + Route]
• To create a SUMO configuration, you need to create a .sumocfg file. This file is an XML file that specifies the various parameters of your SUMO simulation, including the name of the road network file(Map.net.xml), the name of the route file(Route.rou.xml), and the duration of the simulation.
sumo -c Sumo.sumocfg
• Once you have created your SUMO configuration file, you can run the simulation using the "sumo" command-line tool, specifying the name of the configuration file as an argument
• This will start the simulation and display the results in the console. You can also specify output files for the simulation, which will be generated at the end of the simulation and can be used to analyze the results.
2 Created local blockchain network [Ganache] for testing Ganache is a personal blockchain for Ethereum development, which allows developers to create and test smart contracts and decentralized applications (dApps) on a local blockchain network. It is particularly useful for testing and development because it provides a sandbox environment that is isolated from the main Ethereum network, meaning that developers can experiment with their code without risking any real Ether or valuable data. It can be installed quickly and easily on any operating system and integrates with many popular development frameworks and tools, including Truffle, Remix, and Web3.js.
2.1 Launched Ganache To launch Ganache, you can follow these simple steps:
• First, download and install Ganache from the official website.
• Once installed, open Ganache and you will be greeted by a clean and user-friendly interface.
• You can choose to either start a new workspace or open an existing one.
• In the workspace, you can customize various parameters, such as the number of accounts, the initial balance of each account, and the gas limit and price.
• You can also choose to import existing accounts or create new ones from scratch.
• Once you have configured your workspace, click on "Start" and Ganache will launch a local blockchain network on your machine..
2.2 Configured network settings (Hostname, port, network id) Configuring network settings in Ganache is a straightforward process. Here are the steps to follow:
• Open Ganache and start or open a workspace.
• Go to the "Server" tab in the workspace settings.
• Set the "Hostname" to the IP address or domain name of the machine running Ganache (default is "127.0.0.1").
• Set the "Port" to the desired port number for Ganache to listen on (default is "7545").
• Set the "Network ID" to a unique identifier for your private network (default is "5777").
• Start your private blockchain in Ganache with the configured network settings.
• Connect to the Ganache network from your dApp or other Ethereum tools.
3 Deployed a smart contract into that Blockchain network
*3.1 Wrote smart contract * A smart contract is a self-executing program that runs on a blockchain network. It contains a set of rules and conditions that govern the execution of the contract. Smart contracts are typically written in Solidity, a programming language used specifically for Ethereum-based blockchain networks. The smart contract defines the logic and rules that govern a specific set of transactions on the network.
• We have written a smart contract to store and manage information related to vehicles in a decentralized manner on a blockchain network. It defines a struct to represent a vehicle and uses a mapping to store vehicle data by ID. The smart contract also provides functions to retrieve and update vehicle data.
• In that smart contract we have defined the struct with properties:
o id: a string to represent the unique identifier of the vehicle
o speed: an integer to represent the speed of the vehicle
o route: a dynamic array of strings to represent the path taken by the vehicle
o current_edge_id: a string to represent the current edge on which the vehicle is traveling
o route_index: an integer to represent the current index of the vehicle on the route
o next_edge: a string to represent the next edge on the vehicle's route
o next_edge_vehicles: a dynamic array of strings to represent the IDs of other vehicles traveling on the next edge
• We have defined mapping to store vehicle data by vehicle ID
• We have defined functions to retrieve and update the vehicle data by vehicle ID
3.2 Deploy Smart Contract to the local blockchain network
3.2.1 Connected Ganache with truffle
• To connect Ganache with Truffle:
• Initialize a Truffle project using "truffle init" command.
• Configure network settings in truffle-config.js, matching Ganache's port and defining deployment/testing accounts.
• Save the truffle-config.js file.
• Ensure Ganache is running on the default port 7545. Now, Truffle is connected to Ganache for seamless interaction with the local blockchain network.
3.2.2 Compiled smart contract Compiling a smart contract is the process of translating the human-readable Solidity code into machine-readable bytecode that can be executed on the Ethereum Virtual Machine (EVM). When you run the “truffle compile” command, Truffle will look for all the Solidity files in your project's “contracts/” directory and its subdirectories. It will then compile each file individually, creating an ABI (Application Binary Interface) file and a bytecode file for each contract. The ABI file contains a description of the functions and events in the contract, which can be used by other programs to interact with the contract. The bytecode file is the actual executable code that will be deployed to the blockchain. During the compilation process, Truffle will also check for errors in your code, such as syntax errors or type mismatches, and will warn you if any are found. This can help catch bugs early and save time in the long run. Once the compilation is complete, Truffle will output the ABI and bytecode files for each contract, which can then be used to deploy the contract to a blockchain network.
3.2.3 Deployed smart contract Deploying a smart contract means publishing the compiled smart contract to a blockchain network so that it can be executed and accessed by users. In the context of Truffle, the deployment process involves creating a migration file that specifies the details of the smart contract deployment, such as the contract address, transaction hash, and the network on which it is deployed. To deploy a smart contract using Truffle, you first need to create a migration file inside the “migrations” directory. The file name should be in the format “n_deploy_contract.js”, where n is the migration order number. Inside the migration file, you need to use the deployer object to deploy the smart contract. The deployer object has a deploy function that takes the contract's compiled artifact as an argument and deploys it to the specified network. Once the contract is deployed, you can access its address using the address property of the deployed instance. After creating the migration file, you can deploy the smart contract by running the “truffle migrate” command. Truffle will automatically detect new migration files and execute them in the order they were created. Once the deployment process is complete, Truffle will display the contract address, transaction hash, balance, gas used and gas price on the console. It's important to note that when deploying a smart contract, you need to specify the network on which it will be deployed. This can be done by setting the network property in the truffle-config.js file. Additionally, you may need to specify the account that will be used to deploy the contract if you are working with a private network or a test network.
3.3 Deploy Smart Contract to the Fantom mainnet
3.3.1 Connected Remix IDE with Metamask Wallet • Install the Metamask extension for your web browser and create an account if you haven't already.
• Open Remix IDE (https://remix.ethereum.org/) in your web browser.
• In the Remix IDE, click on the "Settings" tab on the left-hand side. Under the "General" section, select "Injected Web3" as the environment. This will connect Remix IDE with your Metamask wallet.
• Metamask will prompt you to connect to the Remix IDE. Click on the "Connect" button to establish the connection.
3.3.2 Compiled a Smart Contract
• Write or import the smart contract code into the Remix IDE.
• In the Remix IDE, click on the "Solidity Compiler" tab on the left-hand side.
• Select the version of Solidity that your smart contract is written in.
• Click on the "Compile" button to compile your smart contract. The compiled contract artifacts(ABI) will be displayed in the right panel.
3.3.3 Deployed a Smart Contract
• In the Remix IDE, switch to the "Deploy & Run Transactions" tab on the left-hand side.
• Under the "Environment" section, select "Injected Web3" to ensure it is connected to your Metamask wallet.
• Choose the contract you want to deploy from the drop-down menu in the "Deploy" section.
• Set the constructor arguments if required.
• Select the account from your Metamask wallet that you want to use for the deployment.
• Click on the "Deploy" button to initiate the deployment process.
• Metamask will prompt you to confirm the transaction and pay the gas fee. Review the details and confirm the transaction.
• Wait for the deployment process to complete. You can view the transaction details and contract address in the Remix IDE.
• Once the deployment is successful, you can interact with your deployed smart contract using the provided contract address.
4 Decision making using Python Script
4.1 Connected Python script with ganache network
4.1.1 Connected Python script with ganache network using web3 API Ganache is a personal blockchain for Ethereum development, and web3.js is a collection of libraries that allow you to interact with a local or remote Ethereum node using JavaScript. To connect Python with Ganache network, we can use the web3.py library, which is a Python implementation of web3.js
• Install web3.py library
• Import web3
• Connect to ganache: To connect to Ganache network, you need to create an instance of the Web3 class and pass the HTTP provider URL of the Ganache network as a parameter.
• Interact with Ganache: Once you are connected to Ganache, you can use the web3.py library to interact with the network. For example, you can get the accounts on the Ganache network by calling the eth.accounts property on the web3 instance. These are the basic steps to connect a Python script with Ganache network using web3.py. You can use the same approach to interact with the blockchain on the Ganache network and update/retrieve VIoT vehicle data using smart contract functions.
4.1.2 Got individual VIoT vehicle data using Traci. Traci (Traffic Control Interface) is a powerful tool for traffic simulation, which can be used to simulate traffic scenarios and control the movement of vehicles in a traffic network. To get individual VIoT vehicle data using Traci, you would typically follow these steps:
• First, you would need to set up a traffic scenario using a traffic network file in SUMO (Simulation of Urban Mobility), which is a widely-used traffic simulation software.
• Next, you would create a Python script to interact with the traffic simulation using Traci. This script would typically initialize the simulation, connect to the simulation using Traci, and control the movement of vehicles in the traffic network.
• You can then use Traci to retrieve data for individual VIoT vehicles in the traffic network. This might include data such as the current speed of the vehicle, its location, the current route it is following, and any other relevant data that you need.
• Once you have retrieved the relevant data, you can use it to make decisions about how to update the VIoT vehicle's behavior, such as adjusting its speed or changing its route.
• In order to integrate Traci with your VIoT project, you would need to ensure that the data you retrieve from Traci is compatible with the format and requirements of your smart contract on the blockchain network.
4.1.3 Updated VIoT vehicle data to the local blockchain network using smart contract functions.
• To update VIoT vehicle data to the local blockchain network using smart contract functions, first you need to write and deploy a smart contract that can accept VIoT vehicle data and update it on the blockchain. You can then use web3.js and web3.py to interact with the smart contract from your Python script.
• Then Instantiate the smart contract using the contract's address and ABI (Application Binary Interface) in your Python script.
• Call the smart contract function that updates the VIoT vehicle data by passing the necessary parameters. The transaction will be sent to the local blockchain network for processing.
• Wait for the transaction to be mined and confirmed on the blockchain. You can use web3.py to monitor the transaction status. By following these steps, you can update VIoT vehicle data on the local blockchain network using smart contract functions.
4.1.4 Retrieved VIoT vehicle data using smart contract functions Retrieving VIoT vehicle data using smart contract functions involves querying the blockchain for the specific data that you want to retrieve. This requires that you know the address of the smart contract containing the data, as well as the function that you need to call to retrieve the data. Once you have this information, you can use a web3.js library to interact with the smart contract and retrieve the data. The specific function that you call will depend on the data that you want to retrieve. For example, if you wanted to retrieve the speed of a particular VIoT vehicle, you would need to call the function in the smart contract that returns that specific piece of data. After calling the function, the smart contract will execute the function code and return the requested data to your Python script. You can then use this data to update your application or make decisions based on the retrieved data. After successful testing, we deployed our smart contract on the Fantom mainnet to enable retrieval of VIoT vehicle data.
4.2 Connected Python script with Fantom mainnet
4.2.1 Connected Python script with Fantom mainnet using web3 API The Fantom mainnet is the main network of the Fantom blockchain. It is a decentralized, high-performance blockchain platform designed to enable fast and secure transactions, as well as support the development of decentralized applications (dApps) and smart contracts. To connect Python with Fantom network, we can use the web3.py library, which is a Python implementation of web3.js
• Install web3.py library
• Import web3
• Connect to Fantom Opera: To connect to Fantom mainnet, you need to create an instance of the Web3 class and pass the HTTP provider URL of the Fantom Opera network as a parameter.
• Interact with Fantom mainnet: Once you are connected to Fantom mainnet, you can use the web3.py library to interact with the Fantom mainnet and update/retrieve VIoT vehicle data using smart contract functions.
4.2.2 Got individual VIoT vehicle data using Traci. Traci (Traffic Control Interface) is a powerful tool for traffic simulation, which can be used to simulate traffic scenarios and control the movement of vehicles in a traffic network. To get individual VIoT vehicle data using Traci, you would typically follow these steps:
• First, you would need to set up a traffic scenario using a traffic network file in SUMO (Simulation of Urban Mobility), which is a widely-used traffic simulation software.
• Next, you would create a Python script to interact with the traffic simulation using Traci. This script would typically initialize the simulation, connect to the simulation using Traci, and control the movement of vehicles in the traffic network.
• You can then use Traci to retrieve data for individual VIoT vehicles in the traffic network. This might include data such as the current speed of the vehicle, its location, the current route it is following, and any other relevant data that you need.
• Once you have retrieved the relevant data, you can use it to make decisions about how to update the VIoT vehicle's behavior, such as adjusting its speed or changing its route.
• In order to integrate Traci with your VIoT project, you would need to ensure that the data you retrieve from Traci is compatible with the format and requirements of your smart contract on the blockchain network.
4.2.3 Updated VIoT vehicle data to the Fantom mainnet using smart contract functions.
• To update VIoT vehicle data to the Fantom network using smart contract functions, first you need to write and deploy a smart contract that can accept VIoT vehicle data and update it on the blockchain. You can then use web3.js and web3.py to interact with the smart contract from your Python script.
• Then Instantiate the smart contract using the contract's address and ABI (Application Binary Interface) in your Python script.
• Call the smart contract function that updates the VIoT vehicle data by passing the necessary parameters. The transaction will be sent to the Fantom network for processing.
• Wait for the transaction to be mined and confirmed on the blockchain. You can use web3.py to monitor the transaction status. By following these steps, you can update VIoT vehicle data on the Fantom mainnet using smart contract functions.
4.2.4 Retrieved VIoT vehicle data using smart contract functions Retrieving VIoT vehicle data using smart contract functions involves querying the blockchain for the specific data that you want to retrieve. This requires that you know the address of the smart contract containing the data, as well as the function that you need to call to retrieve the data. Once you have this information, you can use a web3.js library to interact with the smart contract and retrieve the data. The specific function that you call will depend on the data that you want to retrieve. For example, if you wanted to retrieve the speed of a particular VIoT vehicle, you would need to call the function in the smart contract that returns that specific piece of data. After calling the function, the smart contract will execute the function code and return the requested data to your Python script. You can then use this data to update your application or make decisions based on the retrieved data.
5 Verify and Publish the source code of Smart Contract on the Fantom netwrok
To verify and publish the source code of a smart contract on the Fantom network, you can follow these steps:
• Prepare your Contract Source Code: Make sure you have the complete and unmodified source code of your smart contract available. If your contract consists of multiple files, you may need to combine and flatten them into a single file.
• Compile and Obtain the Bytecode and ABI: Use a Solidity compiler or development framework (e.g., Remix, Hardhat, Truffle) to compile your smart contract. Compile it using the same compiler version and settings you used for deployment. The compilation process will provide you with the bytecode and Application Binary Interface (ABI) of your contract.
• Access the Fantom Explorer: Go to the Fantom Explorer website at https://explorer.fantom.network/.
• Find Your Contract: Using the search bar, locate the deployed contract you want to verify and publish the source code for. Once you find it, click on the contract to access its details.
• Verify Contract Source Code: On the contract's details page, look for a "Verify" or "Submit Source Code" button. Click on it to initiate the verification process.
• Fill in Verification Details: Fill out the verification form with the required information, including:
o Compiler: Select the version of Solidity compiler you used to compile the contract.
o Optimization: Specify whether you enabled or disabled optimization during compilation.
o Contract Name: Enter the name of your smart contract.
o Contract Address: Provide the address of your deployed contract on the Fantom network.
o Source Code: Paste the entire source code of your contract in the verification form. Make sure it matches the compiled bytecode and ABI.
• Submit Verification Request: Double-check all the details you entered and submit the verification request. This will start the verification process.
• Wait for Verification: The verification process may take some time. Be patient and wait for the verification to complete. Once done, you should see the verified contract details on the contract's page.
By following these steps, we can able to verify and publish the source code of your smart contract on the Fantom network through the Fantom Explorer. This helps enhance transparency, code auditability, and user confidence in the contract's functionality.
6 Testing Working on a local blockchain network involves setting up a blockchain network on a local machine or server for testing and development purposes. This is typically done using a blockchain development framework such as Ganache or Truffle, which allows for the creation of a private, local blockchain network that can be used to test smart contracts and other blockchain applications without incurring the cost or complexity of a public blockchain. Deploying a smart contract on a local blockchain network is a great way to test and refine the functionality of the system before moving to a larger, private blockchain network. By starting with a local network, you can easily monitor and troubleshoot any issues that arise, without worrying about the complexities of a larger, more distributed network. Once you are satisfied with the performance and security of your smart contract and the local network, it may be time to transition to blockchain network. Working on a local blockchain network also allows for easier collaboration between developers, as the network can be easily replicated and shared among team members. Additionally, it provides a sandbox environment for experimentation and innovation, allowing developers to try out new ideas and approaches without risking real-world consequences. However, it's important to note that deploying a smart contract on a local blockchain network is not the same as deploying it to a public or private blockchain network. While a local network can provide a good testing environment, it may not accurately reflect the security, scalability, or performance of a live blockchain network. Therefore, it's important to thoroughly test and validate smart contracts before deploying them to any blockchain network.
Challenges we ran into
Throughout our project on AI integrated blockchain for autonomous vehicles, we encountered various challenges that tested our perseverance and problem-solving abilities.
One of the significant challenges we encountered was related to gas fee on the Fantom network. Gas fee are the fees required to execute transactions and smart contracts on the blockchain. The fluctuating gas fees and transaction costs posed obstacles to the seamless deployment and interaction with our smart contracts on the Fantom network. We had to carefully manage our available FTM tokens to ensure we had sufficient funds to cover the gas fees for our transactions. Additionally, the unpredictability of gas fees sometimes affected the cost-effectiveness of our smart contract operations, especially when dealing with complex or resource-intensive transactions. Additionally, we faced the difficulty of finding comprehensive and reliable sources specific to our project, requiring extensive research and exploration.
Despite these challenges, we remained determined and committed to the project's success. We invested countless sleepless days and nights into overcoming the obstacles we encountered. Our team conducted thorough research, delving into academic papers, industry reports, and related projects to adapt existing knowledge to our use case. We actively engaged with experts, peers, and online communities to seek guidance and exchange ideas.
By maintaining our commitment to learning and problem-solving, we successfully navigated the limited available sources and delivered a robust AI integrated blockchain solution for autonomous vehicles. The project not only expanded our understanding of the subject matter but also honed our resourcefulness and critical thinking skills.
Overall, our journey involved both technical and research-oriented challenges, which we tackled with determination and dedication. Overcoming these hurdles has not only contributed to the project's success but has also equipped us with invaluable skills for future endeavors in the field of AI integrated blockchain for autonomous vehicles. r## Accomplishments that we're proud of Throughout the development of the "Decentralized Autonomous Vehicles" (DAV) project, we have achieved several significant accomplishments that we are proud of. These accomplishments demonstrate our commitment to innovation, technical expertise, and addressing real-world challenges in the transportation industry. Here are some of our key achievements:
1 Successful Integration of Blockchain and Autonomous Vehicles: We have successfully integrated blockchain technology with autonomous vehicles, creating a decentralized network that enables secure and real-time decision-making. This accomplishment required in-depth research, technical expertise, and collaboration between blockchain developers and autonomous vehicle experts.
2 Implementation of Vehicular IoT (VIoT) and VANET with Blockchain: We have effectively implemented Vehicular IoT and Vehicular Ad-hoc Network (VANET) technologies to facilitate communication and data exchange among autonomous vehicles within the DAV network. This achievement required designing robust communication protocols and ensuring data security and privacy.
3 Development of a Secure and Transparent System: We have created a system that guarantees data security, privacy, transparency, traceability, and protection against unauthorized access or data tampering/destruction. By leveraging the immutable nature of blockchain, we ensure the integrity and authenticity of the data shared among autonomous vehicles.
4 Validation of Decentralized Decision-Making: Through rigorous testing and simulations, we have validated the effectiveness of decentralized decision-making within the DAV network. Our system enables vehicles to learn from real-world incidents and make informed decisions based on shared knowledge, ultimately improving safety and adaptability in complex environments.
Seamless integration with the Fantom network: We are proud to have successfully integrated our decentralized autonomous vehicles project with the Fantom network. By leveraging the Fantom mainnet, we have achieved high-performance transaction processing and cost-effective interactions with our smart contracts. The seamless integration with the Fantom network has allowed us to leverage its scalability, compatibility with the Ethereum Virtual Machine (EVM), and vibrant ecosystem of decentralized applications (dApps) to enhance the functionality and adoption of our decentralized autonomous vehicle network.
What we learned
During the development of the "Decentralized Autonomous Vehicles" (DAV) project, my teammate and I not only gained technical knowledge but also learned important lessons related to teamwork, the autonomous industry, Vehicular IoT (VIoT), Vehicular Ad-hoc Network (VANET), and blockchain. Here's an overview of what we learned:
1 Teamwork: Collaborating with my teammate throughout the project allowed us to leverage each other's strengths, share responsibilities, and effectively communicate ideas and progress. We learned the importance of clear and frequent communication, division of tasks, and supporting each other to achieve our shared goals.
2 Autonomous Industry: Through research and development, we deepened our understanding of the autonomous industry and its potential impact. We studied the latest trends, challenges, and advancements in self-driving vehicles, including the use of blockchain technology for secure decision-making and data sharing. This knowledge enabled us to design a solution that addresses real-world industry needs.
3 Vehicular IoT (VIoT): We explored the concept of Vehicular IoT, which focuses on the integration of vehicles into the broader Internet of Things ecosystem. We learned about the unique challenges and opportunities presented by VIoT, including the secure communication and data exchange between vehicles and their environment. This understanding influenced our design choices and solution architecture.
4 Vehicular Ad-hoc Network (VANET): VANET technology played a crucial role in our project. We familiarized ourselves with VANET protocols and communication mechanisms that enable vehicles to form an ad-hoc network for exchanging data and information. We learned about the benefits of VANET, such as improved traffic management and enhanced safety through vehicle-to-vehicle (V2V) and vehicle-to-infrastructure (V2I) communication.
5 Integration with the Fantom Mainnet: Integrating our project with the Fantom mainnet provided valuable insights into working with a high-performance blockchain network. We learned about the nuances of deploying and interacting with smart contracts on the Fantom network, including gas fees, contract security, and contract verification. This experience deepened our understanding of blockchain technology and its practical application in real-world projects. Integrating with the Fantom mainnet expanded our knowledge of the Fantom ecosystem and its unique features, further enhancing our ability to leverage blockchain technology for decentralized decision-making in the autonomous industry.
6 Industry Integration: The integration of Chainlink into our project exposed us to the practical application of blockchain technology and oracles in the autonomous industry. We gained insights into how blockchain can facilitate decentralized decision-making, data sharing, and secure transactions among autonomous vehicles. This knowledge broadened our perspective on the potential impact of blockchain in transforming the autonomous industry.
7 Interdisciplinary Skills: Developing the DAV project required us to combine knowledge and skills from various disciplines, including blockchain, autonomous vehicles, IoT, networking, and oracles. We learned how to bridge these domains and integrate technologies seamlessly to create a comprehensive solution. This interdisciplinary approach helped us develop a holistic understanding of the challenges and opportunities in the field.
By combining our teamwork, understanding of the autonomous industry, knowledge of VIoT and VANET technologies, and integration of Chainlink, we successfully developed a decentralized decision-making system for autonomous vehicles. These experiences not only enhanced our technical skills but also prepared us for future endeavors in the autonomous industry and emerging technologies.
What's next for AI Integrated Blockchain for Autonomous Vehicles
Our next steps involve real-world deployment, scaling and network expansion, enhanced security and privacy, collaboration and partnerships, continuous improvement, and community engagement. By pursuing these avenues, we aim to advance the field of decentralized decision-making for autonomous vehicles and contribute to the realization of a safer, more efficient, and decentralized autonomous industry. Additionally, as students working on this project, we are actively searching for good opportunities in companies that are involved in the development of AI integrated blockchain for autonomous vehicles. We are eager to join organizations that align with our project's vision and are actively working on innovative solutions in this field. We believe that by joining a forward-thinking company, we can leverage their resources, knowledge, and industry experience to further enhance our project and contribute to groundbreaking advancements in the industry. We are enthusiastic about exploring potential job opportunities and would be delighted to connect with our dream companies that are at the forefront of AI integrated blockchain for autonomous vehicles. If you are a company seeking talented individuals with a passion for this field, we would be thrilled to engage in discussions and explore how we can contribute to your organization's success.
Log in or sign up for Devpost to join the conversation.