int SpiIO(eSPIOperation op, const uint8_t *ptrData, uint32_t ulDataSize, int waitOnCompletion)
{
eCC3000States current = State();
/* Disable DMA Channels */
CC3000_SPI_DMA_Channels(DISABLE);
if (op == eRead)
{
CC3000_DMA_Config(CC3000_DMA_RX, (uint8_t*) ptrData, ulDataSize);
CC3000_DMA_Config(CC3000_DMA_TX, (uint8_t*) spi_readCommand, ulDataSize);
}
else
{
CC3000_DMA_Config(CC3000_DMA_RX, (uint8_t*) sSpiInformation.pRxPacket, ulDataSize);
CC3000_DMA_Config(CC3000_DMA_TX, (uint8_t*) ptrData, ulDataSize);
}
/* Enable DMA SPI Interrupt */
DMA_ITConfig(CC3000_SPI_TX_DMA_CHANNEL, DMA_IT_TC, ENABLE);
/* Enable DMA Channels */
CC3000_SPI_DMA_Channels(ENABLE);
return waitOnCompletion ? Still(current) : 0;
}
int main(int argc, char* argv[]) {
// Check arguments
if (argc < 5) {
std::cerr << "Usage: final_project NODES_FILE TRIS_FILE ball.nodes ball.tris \n";
exit(1);
}
MeshType mesh;
std::vector<typename MeshType::node_type> mesh_node;
// Read all water Points and add them to the Mesh
std::ifstream nodes_file(argv[1]);
Point p;
uint water_nodes = 0;
while (CS207::getline_parsed(nodes_file, p)) {
mesh_node.push_back(mesh.add_node(p));
water_nodes++;
}
// Read all water mesh triangles and add them to the Mesh
std::ifstream tris_file(argv[2]);
std::array<int,3> t;
int water_tris = 0;
while (CS207::getline_parsed(tris_file, t)) {
mesh.add_triangle(mesh_node[t[0]], mesh_node[t[1]], mesh_node[t[2]]);
water_tris++;
}
uint water_edges = mesh.num_edges();
std::ifstream nodes_file2(argv[3]);
double radius = 1 * scale;
while (CS207::getline_parsed(nodes_file2, p)) {
p *= scale;
p.z += + start_height;
mesh_node.push_back(mesh.add_node(p));
}
// Read all ball mesh triangles and add them to the mesh
std::ifstream tris_file2(argv[4]);
while (CS207::getline_parsed(tris_file2, t)) {
mesh.add_triangle(mesh_node[t[0]+water_nodes], mesh_node[t[1]+water_nodes], mesh_node[t[2]+water_nodes]);
}
// Print out the stats
std::cout << mesh.num_nodes() << " "
<< mesh.num_edges() << " "
<< mesh.num_triangles() << std::endl;
/* Set the initial conditions */
// Set the initial values of the nodes and get the maximum height double
double max_h = 0;
double dx = 0;
double dy = 0;
auto init_cond = Still();
auto b_init_cond = Cone();
// Find the maximum height and apply initial conditions to nodes
for (auto it = mesh.node_begin(); it != mesh.node_end(); ++it) {
auto n = *it;
if (n.index() < water_nodes){
n.value().q = init_cond(n.position());
n.value().b = b_init_cond(n.position());
max_h = std::max(max_h, n.value().q.h);
}
else {
n.value().q = QVar(n.position().z, 0, 0);
n.value().mass = total_mass/(mesh.num_nodes() - water_nodes);
n.value().velocity = Point(0.0,0.0,0.0);
}
}
// Set the initial values of the triangles to the average of their nodes and finds S
// Set the triangle direction values so that we can determine which
// way to point normal vectors. This part assumes a convex shape
Point center = get_center(mesh);
for (auto it = mesh.triangle_begin(); it != mesh.triangle_end(); ++it) {
auto t = *it;
if (t.index() < water_tris){
t.value().q_bar = (t.node1().value().q +
t.node2().value().q +
t.node3().value().q) / 3.0;
t.value().q_bar2 = t.value().q_bar;
double b_avg = (t.node1().value().b +
t.node2().value().b +
t.node3().value().b) / 3.0;
// finds the max dx and dy to calculate Source
dx = std::max(dx, fabs(t.node1().position().x - t.node2().position().x));
dx = std::max(dx, fabs(t.node2().position().x - t.node3().position().x));
dx = std::max(dx, fabs(t.node3().position().x - t.node1().position().x));
dy = std::max(dy, fabs(t.node1().position().y - t.node2().position().y));
dy = std::max(dy, fabs(t.node2().position().y - t.node3().position().y));
dy = std::max(dy, fabs(t.node3().position().y - t.node1().position().y));
t.value().S = QVar(0, -grav * t.value().q_bar.h * b_avg / dx, -grav * t.value().q_bar.h * b_avg / dy);
}
else
set_normal_direction((*it),center);
}
// Calculate the minimum edge length and set edge inital condititons
double min_edge_length = std::numeric_limits<double>::max();
uint count = 0;
for (auto it = mesh.edge_begin(); it != mesh.edge_end(); ++it, count++){
if (count < water_edges)
min_edge_length = std::min(min_edge_length, (*it).length());
else {
(*it).value().spring_constant = spring_const;
(*it).value().initial_length = (*it).length();
}
}
// Launch the SDLViewer
CS207::SDLViewer viewer;
viewer.launch();
auto node_map = viewer.empty_node_map(mesh);
viewer.add_nodes(mesh.node_begin(), mesh.node_end(),
Color(water_nodes), NodePosition(), node_map);
viewer.add_edges(mesh.edge_begin(), mesh.edge_end(), node_map);
// adds solid color-slows down program significantly
//viewer.add_triangles(mesh.triangle_begin(), mesh.triangle_end(), node_map);
viewer.center_view();
// CFL stability condition requires dt <= dx / max|velocity|
// For the shallow water equations with u = v = 0 initial conditions
// we can compute the minimum edge length and maximum original water height
// to set the time-step
// Compute the minimum edge length and maximum water height for computing dt
double dt = 0.25 * min_edge_length / (sqrt(grav * max_h));
double t_start = 0;
double t_end = 10;
Point ball_loc = Point(0,0,0);
double dh = 0;
// double pressure = gas_const/(4/3*M_PI*radius*radius*radius);
// add listener
my_listener* l = new my_listener(viewer,mesh,dt);
viewer.add_listener(l);
// Preconstruct a Flux functor
EdgeFluxCalculator f;
// defines the constraint
PlaneConstraint c = PlaneConstraint(plane_const);
// Begin the time stepping
for (double t = t_start; t < t_end; t += dt) {
// define forces on ball
GravityForce g_force;
BuoyantForce b_force = BuoyantForce(dh, ball_loc.z);
WindForce w_force;
MassSpringForce ms_force;
// PressureForce p_force = PressureForce(pressure);
// DampingForce d_force = DampingForce(mesh.num_nodes());
auto combined_forces = make_combined_force(g_force, b_force, w_force, ms_force);
// Step forward in time with forward Euler
hyperbolic_step(mesh, f, t, dt, ball_loc, water_tris);
// Update node values with triangle-averaged values
ball_loc = post_process(mesh, combined_forces, c, t, dt, water_nodes);
// Update the viewer with new node positions
viewer.add_nodes(mesh.node_begin(), mesh.node_end(),
Color(water_nodes), NodePosition(), node_map);
// viewer.add_triangles(mesh.triangle_begin(), mesh.triangle_end(), node_map);
viewer.set_label(t);
// find radius of cross sectional radius of ball submerged
dh = ball_loc.z;
if (dh > 2*radius)
dh = 2 * radius;
ball_loc.z = cross_radius(radius, dh);
// These lines slow down the animation for small meshes.
if (mesh.num_nodes() < 100)
CS207::sleep(0.05);
}
return 0;
}