void Modem_SIM800::Call(FoneOSString number)
{
mraa_uart_write(this->_serial, "ATD", strlen("ATD"));
char * cNumber = Utils::FoneOSStringToCharArray(number);
mraa_uart_write(this->_serial, cNumber, strlen(cNumber));
free(cNumber);
mraa_uart_write(this->_serial, ";\r\n", strlen("\r\n"));
}
void Modem_SIM800::WriteLine(std::string line)
{
while(mraa_uart_data_available(this->_serial, 100))
{
char deadBuf[2] = {0};
mraa_uart_read(this->_serial, deadBuf, 1);
} // clear responses
mraa_uart_write(this->_serial, line.c_str(), strlen(line.c_str()));
mraa_uart_write(this->_serial, "\r\n", strlen("\r\n"));
Logging::LogMessage(std::string("--> ") + line);
}
upm_result_t ecezo_write(const ecezo_context dev, char *buffer, size_t len)
{
assert(dev != NULL);
if (dev->uart)
{
if (mraa_uart_write(dev->uart, buffer, len) != (int)len)
{
printf("%s: mraa_uart_write() failed.\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
}
else
{
// I2C
if (mraa_i2c_write(dev->i2c, (uint8_t *)buffer, len))
{
printf("%s: mraa_i2c_write() failed.\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
}
return UPM_SUCCESS;
}
int rn2903_write(const rn2903_context dev, const char *buffer, size_t len)
{
assert(dev != NULL);
int rv = mraa_uart_write(dev->uart, buffer, len);
mraa_uart_flush(dev->uart);
return rv;
}
void serial_println(const char *line, int len){
if(uart!=NULL){
char *cpstr = (char *)malloc((len+1) *sizeof(char));
strcpy(cpstr,line);
cpstr[len-1] ='\r';
cpstr[len] = '\n';
int count = mraa_uart_write(uart, cpstr, len+1);
if (count < 0){}
free(cpstr);
}
}
mrb_value mrb_mraa_uart_write(mrb_state *mrb, mrb_value self) {
mraa_uart_context uart;
mraa_result_t result;
char *string;
size_t l = 0;
mrb_get_args(mrb, "s", &string, &l);
uart = (mraa_uart_context)mrb_data_get_ptr(mrb, self, &mrb_mraa_uart_ctx_type);
result = mraa_uart_write(uart, string, l);
if (result < 0) {
mrb_raisef(mrb, E_RUNTIME_ERROR, "Could not write (err %S)",
mrb_fixnum_value(result));
}
return mrb_fixnum_value(result);
}
int main(){
load_device_tree("ADAFRUIT-UART4");
mraa_uart_context bbb;
bbb = mraa_uart_init_raw("/dev/ttyO4");
mraa_uart_set_baudrate(bbb, 38400);
mraa_uart_set_mode(bbb, 8,MRAA_UART_PARITY_NONE , 1);
char buf[31] = "~4121|p123.324321|n053.989876$";
buf[30] = '\0';
while (1) {
mraa_uart_write(bbb, buf, 30);
usleep(10000);
}
return 0;
}
void sendToModem(char* buffer, int len){
//int ans = 1, i=0;
// unsigned char s[1] = {10};
/*while(ans==1 && i < len){
printf("send byte #%d : %d\n", i, buffer[i]);
ans = mraa_uart_write( uart , &buffer[i], 1);
i++;
}*/
//ans = mraa_uart_write( uart , s, 1);
char buff[1]={10};
int ans=0;
ans = mraa_uart_write( uart , buffer, len);
printf("try to write to uart %d [byte].\twrote %d [byte]\n", len, ans);
//mraa_uart_write( uart, buff, 1);
}
/**
* Write bytes in String object to a device
*
* @param string to write
* @return the number of bytes written, or -1 if an error occurred
*/
int
writeStr(std::string data)
{
// this is data.length() not +1 because we want to avoid the '\0' char
return mraa_uart_write(m_uart, data.c_str(), (data.length()));
}
/**
* Write bytes in char* buffer to a device
*
* @param data buffer pointer
* @param length maximum size of buffer
* @return the number of bytes written, or -1 if an error occurred
*/
int
write(const char* data, int length)
{
return mraa_uart_write(m_uart, data, (size_t) length);
}
int main(){
/**********************************************************************/
/**********************************************************************/
/* Begin. */
mraa_uart_context uart;
uart = mraa_uart_init(0);
mraa_uart_set_baudrate(uart, 115200);
char buffer[] = "hhh";
char flush[]="xxxxxxxxxxxx";
char str[] = "HELLO";
if (uart == NULL) {
fprintf(stderr, "UART failed to setup\n");
printf("UART failed");
return 1;
}
printf("firstavail:%d\n",mraa_uart_data_available(uart,0));
while (mraa_uart_data_available(uart,0))
{
mraa_uart_read(uart, flush, sizeof(uart));
printf("Flush: %c %c %c %c %c %c %c %c",flush[0], flush[1], flush[2],flush[3],flush[4],flush[5],flush[6],flush[7]);
usleep(150);
}
printf("available: %d",mraa_uart_data_available(uart,0));
char speed_user_input[MAXBUFSIZ];
char turn_user_input[MAXBUFSIZ];
mraa_pwm_context speed_pwm_in1, speed_pwm_in2, turn_pwm;
speed_pwm_in1 = mraa_pwm_init(3);
speed_pwm_in2 = mraa_pwm_init(5);
turn_pwm = mraa_pwm_init(6);
if (speed_pwm_in1 == NULL || speed_pwm_in2 == NULL || turn_pwm == NULL) {
fprintf(stderr, "Failed to initialized.\n");
return 1;
}
mraa_pwm_period_us(speed_pwm_in1,870); //1150Hz
mraa_pwm_enable(speed_pwm_in1, 1);
mraa_pwm_period_us(speed_pwm_in2,870);
mraa_pwm_enable(speed_pwm_in2, 1);
mraa_pwm_period_ms(turn_pwm,20);
mraa_pwm_enable(turn_pwm, 1);
mraa_pwm_write(turn_pwm, CENTER);
mraa_pwm_write(speed_pwm_in1, 1.0f);
mraa_pwm_write(speed_pwm_in2, 1.0f);
int n = 5;
int spd = 0;
char direction = 'C';
char cross_clr = 'B';
float angle = 0.0f;
while (1)
{
//sleep(2);
//readCharAry(uart,flush);
spd = 50;
mraa_uart_read(uart, buffer, 1);
if(buffer[0]=='\n')
{
printf("new line ");
mraa_uart_read(uart, buffer, 1);
if(buffer[0]=='\n')
{
printf("new line ");
mraa_uart_read(uart, buffer, 1);
}
}
mraa_uart_read(uart, buffer+1, 1);
if(buffer[1]=='\n')
{
buffer[0] = 'h';
buffer[1] = 'h';
}
int sign = 0;
if(cross_clr == 'M')
{
speed_control(speed_pwm_in1, speed_pwm_in2, 0.0f);
sleep(1);
char* nearestBeaconID = (char*)malloc(5);
getStrongestBeacon(nearestBeaconID);
printf("the nearestBeaconID is: %s\n", nearestBeaconID);
sign = 1;
angle = CENTER + 0.015f;
mraa_pwm_write(turn_pwm, angle);
usleep(15000);
speed_control(speed_pwm_in1, speed_pwm_in2, 54);
printf("speed: %d",spd);
usleep(5500000);
speed_control(speed_pwm_in1, speed_pwm_in2, 0.0f);
//sleep(1);
mraa_uart_write(uart, str, 1);
//while(!mraa_uart_data_available(uart, 10)){};
mraa_uart_read(uart, buffer, 1);
while(buffer[0] == '\n')
{
mraa_uart_read(uart, buffer, 1);
}
if(buffer[0] == '\0') direction = 'C';
mraa_uart_read(uart, buffer + 1, 1);
cross_clr = buffer[1];
}
printf("buff:%c %c %c \n",buffer[0], buffer[1],buffer[2]);
if(!sign){
if (direction == 'L') angle = CENTER - 0.005f;
if (direction == 'R') angle = CENTER + 0.005f;
if (direction == 'C') angle = CENTER;}
else
{
if (direction == 'C') angle = CENTER +0.013f;
if (direction == 'L') angle = CENTER +0.005f;
if (direction == 'R') angle = CENTER + 0.019f;
}
mraa_pwm_write(turn_pwm, angle);
speed_control(speed_pwm_in1, speed_pwm_in2, spd);
printf("speed: %d",spd);
usleep(250000);
direction = buffer[0];
cross_clr = buffer[1];
}
return 0;
}
int main()
{
int sampleCount = 0;
int sampleRate = 0;
uint64_t rateTimer;
uint64_t displayTimer;
uint64_t now;
// Using RTIMULib here allows it to use the .ini file generated by RTIMULibDemo.
// Or, you can create the .ini in some other directory by using:
// RTIMUSettings *settings = new RTIMUSettings("<directory path>", "RTIMULib");
// where <directory path> is the path to where the .ini file is to be loaded/saved
RTIMUSettings *settings = new RTIMUSettings("RTIMULib");
RTIMU *imu = RTIMU::createIMU(settings);
if ((imu == NULL) || (imu->IMUType() == RTIMU_TYPE_NULL)) {
printf("No IMU found\n");
exit(1);
}
// This is an opportunity to manually override any settings before the call IMUInit
// set up IMU
imu->IMUInit();
// this is a convenient place to change fusion parameters
imu->setSlerpPower(0.02);
imu->setGyroEnable(true);
imu->setAccelEnable(true);
imu->setCompassEnable(true);
// Set up serial out UART ports
mraa_uart_context uart;
//uart = mraa_uart_init(0);
uart=mraa_uart_init_raw("/dev/ttyGS0");
mraa_uart_set_baudrate(uart, 9600);
if (uart == NULL) {
fprintf(stderr, "UART failed to setup\n");
return 0;
}
char buffer[20]={}; // To hold output
while (1) {
while (imu->IMURead()) {
RTIMU_DATA imuData = imu->getIMUData();
//sleep(1);
printf("%s\r", RTMath::displayDegrees("Gyro", imuData.fusionPose) );
//printf("\nx %f ",imuData.gyro.x()*(180.0/3.14));
//printf("\ny %f ",imuData.gyro.y()*(180.0/3.14));
//printf("\nz %f\n",imuData.gyro.z()*(180.0/3.14));
sprintf(buffer,"%4f\n",imuData.fusionPose.x()*(180.0/3.14));
mraa_uart_write(uart, buffer, sizeof(buffer));
printf("\n\n");
//imuData.
fflush(stdout);
//displayTimer = now;
}
}
mraa_uart_stop(uart);
mraa_deinit();
}
