public boolean alignStraight() {
double angleOut = gyro.getAngle() * Preferences.getInstance().getDouble("Gyro_kP", 0.0);
SmartDashboard.putNumber("gyroErr", gyro.getAngle());
SmartDashboard.putNumber("angleOut", angleOut);
robotDrive.arcadeDrive(0, angleOut);
if (Math.abs(gyro.getAngle()) < Preferences.getInstance().getDouble("AngleBuffer", 100)) {
arcadeDrive(0, 0);
return true;
}
return false;
}
private Notifications(Context context) {
this.applicationContext = context.getApplicationContext();
this.preferences = Preferences.getInstance(applicationContext);
this.gcm = Gcm.getInstance(applicationContext);
this.notificationIds = new HashMap<>();
this.notificationIdCount = 0;
}
// basic arcadeDrive: y=forward/backward speed, x=left/right speed
public void arcadeDrive(double y, double x) {
Preferences p = Preferences.getInstance();
final boolean kReverseDirection = p.getBoolean("DriveTrainReverseDirection", false);
robotDrive.setInvertedMotor(RobotDrive.MotorType.kRearLeft, kReverseDirection);
robotDrive.setInvertedMotor(RobotDrive.MotorType.kRearRight, kReverseDirection);
robotDrive.arcadeDrive(y, x + 0.05);
SmartDashboard.putNumber("DriveTrainGyro", -gyro.getAngle()); // upside down
SmartDashboard.putNumber("RangefinderVoltage", ultraDist.getVoltage());
} // end arcadeDrive
// starts encoders
public DriveTrain() {
leftEncoder.start();
rightEncoder.start();
gyro.reset();
Preferences p = Preferences.getInstance();
if (!p.containsKey("DriveTrainShootLimitVoltage")) {
p.putDouble("DriveTrainShootLimitVoltage", kDefaultShootLimitVoltage);
}
if (!p.containsKey("DriveTrainQuickTurnP")) {
p.putDouble("DriveTrainQuickTurnP", kDefaultQuickTurnProportion);
}
if (!p.containsKey("DriveTrainQuickTurnDeadband")) {
p.putDouble("DriveTrainQuickTurnDeadband", kDefaultQuickTurnDeadband);
}
if (!p.containsKey("DriveTrainReverseDirection")) {
p.putBoolean("DriveTrainReverseDirection", kDefaultReverseDirection);
}
if (!p.containsKey("LeftEncoderRatio")) {
p.putDouble("LeftEncoderRatio", 4.875);
}
if (!p.containsKey("RightEncoderRatio")) {
p.putDouble("RightEncoderRatio", 4.875);
}
if (!p.containsKey("Encoder_kP")) {
p.putDouble("Encoder_kP", 0.05);
}
if (!p.containsKey("OutputMin")) {
p.putDouble("OutputMin", .2);
}
if (!p.containsKey("DistBuffer")) {
p.putDouble("DistBuffer", 1);
}
if (!p.containsKey("Gyro_kP")) {
p.putDouble("Gyro_kP", 1 / 18);
}
if (!p.containsKey("AngleBuffer")) {
p.putDouble("AngleBuffer", 4.5);
}
if (!p.containsKey("AutoDist_0")) {
p.putDouble("AutoDist_0", 0.0);
}
if (!p.containsKey("AutoDist_1")) {
p.putDouble("AutoDist_1", 0.0);
}
if (!p.containsKey("AutoDist_2")) {
p.putDouble("AutoDist_2", 0.0);
}
if (!p.containsKey("AutoDist_3")) {
p.putDouble("AutoDist_3", 0.0);
}
if (!p.containsKey("ShiftWhenTurningThreshold")) {
p.putDouble("ShiftWhenTurningThreshold", 0.5);
}
if (!p.containsKey("ShiftWhenTurningDelay")) {
p.putDouble("ShiftWhenTurningDelay", 1.5);
}
} // end constructor
// basic arcadeDrive: y=forward/backward speed, x=left/right speed
public void arcadeDrive(double y, double x) {
SmartDashboard.putNumber("RightEncoder", rightEncoder.get());
SmartDashboard.putNumber("LeftEncoder", leftEncoder.get());
Preferences p = Preferences.getInstance();
final boolean kReverseDirection = p.getBoolean("DriveTrainReverseDirection", false);
robotDrive.setInvertedMotor(RobotDrive.MotorType.kRearLeft, kReverseDirection);
robotDrive.setInvertedMotor(RobotDrive.MotorType.kRearRight, kReverseDirection);
robotDrive.arcadeDrive(y, x);
} // end arcadeDrive
public void enable() {
rightEncoder.reset();
leftEncoder.reset();
rightEncoder.start();
leftEncoder.start();
gyro.reset();
final boolean kReverseDirection =
Preferences.getInstance().getBoolean("DriveTrainReverseDirection", false);
robotDrive.setInvertedMotor(RobotDrive.MotorType.kRearLeft, kReverseDirection);
robotDrive.setInvertedMotor(RobotDrive.MotorType.kRearRight, kReverseDirection);
} // end enable
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.conversations);
gcm = Gcm.getInstance(getApplicationContext());
billing = Billing.getInstance(getApplicationContext());
database = Database.getInstance(getApplicationContext());
preferences = Preferences.getInstance(getApplicationContext());
Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
ViewCompat.setElevation(toolbar, getResources().getDimension(R.dimen.toolbar_elevation));
setSupportActionBar(toolbar);
LinearLayoutManager layoutManager = new LinearLayoutManager(this);
layoutManager.setOrientation(LinearLayoutManager.VERTICAL);
adapter = new ConversationsRecyclerViewAdapter(this, layoutManager);
recyclerView = (RecyclerView) findViewById(R.id.list);
recyclerView.setHasFixedSize(true);
recyclerView.setLayoutManager(layoutManager);
recyclerView.setAdapter(adapter);
actionMode = null;
actionModeEnabled = false;
SwipeRefreshLayout swipeRefreshLayout =
(SwipeRefreshLayout) findViewById(R.id.swipe_refresh_layout);
swipeRefreshLayout.setOnRefreshListener(
new SwipeRefreshLayout.OnRefreshListener() {
@Override
public void onRefresh() {
preFullUpdate();
}
});
swipeRefreshLayout.setColorSchemeResources(R.color.accent);
ImageButton button = (ImageButton) findViewById(R.id.new_button);
ViewCompat.setElevation(button, getResources().getDimension(R.dimen.fab_elevation));
button.setOnClickListener(
new View.OnClickListener() {
@Override
public void onClick(View v) {
if (!preferences.getEmail().equals("")
&& !preferences.getPassword().equals("")
&& !preferences.getDid().equals("")) {
Intent intent = new Intent(conversationsActivity, NewConversationActivity.class);
startActivity(intent);
}
}
});
SynchronizationIntervalReceiver.setupSynchronizationInterval(getApplicationContext());
}
public void tankDrive(double leftSpeed, double rightSpeed) {
Preferences p = Preferences.getInstance();
final boolean kReverseDirection = p.getBoolean("DriveTrainReverseDirection", false);
robotDrive.setInvertedMotor(RobotDrive.MotorType.kRearLeft, kReverseDirection);
robotDrive.setInvertedMotor(RobotDrive.MotorType.kRearRight, kReverseDirection);
// if (kReverseDirection) {
// robotDrive.tankDrive(rightSpeed, leftSpeed);
// return;
// }
robotDrive.tankDrive(leftSpeed, rightSpeed);
SmartDashboard.putNumber("gyroErr", gyro.getAngle());
SmartDashboard.putNumber("encoder", rightEncoder.get());
} // end tankDrive
// starts encoders
public DriveTrain() {
leftEncoder.start();
rightEncoder.start();
gyro.reset();
Preferences p = Preferences.getInstance();
if (!p.containsKey("DriveTrainShootLimitVoltage")) {
p.putDouble("DriveTrainShootLimitVoltage", kDefaultShootLimitVoltage);
}
if (!p.containsKey("DriveTrainQuickTurnP")) {
p.putDouble("DriveTrainQuickTurnP", kDefaultQuickTurnProportion);
}
if (!p.containsKey("DriveTrainQuickTurnDeadband")) {
p.putDouble("DriveTrainQuickTurnDeadband", kDefaultQuickTurnDeadband);
}
if (!p.containsKey("DriveTrainReverseDirection")) {
p.putBoolean("DriveTrainReverseDirection", kDefaultReverseDirection);
}
} // end constructor
public boolean driveStraight(double dist) {
SmartDashboard.putNumber("RightEncoder", rightEncoder.get());
SmartDashboard.putNumber("LeftEncoder", leftEncoder.get());
Preferences p = Preferences.getInstance();
L_encoderVal =
leftEncoder.get()
/ p.getDouble(
"LeftEncoderRatio",
0.0); // converts encoder value to inches; encoder ratio should be about 58.76
R_encoderVal =
rightEncoder.get()
/ p.getDouble("RightEncoderRatio", 0.0); // converts encoder value to inches
encoderVal = (R_encoderVal); // only one encoder
encoderErr = dist - encoderVal;
distOut =
encoderErr * p.getDouble("Encoder_kP", 0.0)
+ (Math.abs(encoderErr) / encoderErr)
* p.getDouble(
"OutputMin",
0.0); // Encoder kP = 0.5; abs(x)/x returns sign of x; 0.2 is the min. magnitude
gyroErr = gyro.getAngle(); // Setpoint is always 0
double angleOut = gyroErr * p.getDouble("Gyro_kP", 0.0) + .3; // * distOut / Math.abs(distOut);
SmartDashboard.putNumber("encoderErr", encoderErr);
SmartDashboard.putNumber("distOut", distOut);
SmartDashboard.putNumber("gyroErr", gyro.getAngle());
SmartDashboard.putNumber("angleOut", angleOut);
if (Math.abs(encoderErr) < p.getDouble("DistBuffer", 0.0)
&& Math.abs(gyroErr) < p.getDouble("AngleBuffer", 0.0)) {
// leftEncoder.reset();
// rightEncoder.reset();
// gyro.reset();
// arcadeDrive(0, 0);
return true; // returns true when robot gets to its goal
} else {
arcadeDrive(
-distOut,
angleOut); // Gyro kP = 1/18.0; Arcade Drive uses reversed rotate values (neg. goes Left /
// pos. goes Right)
return false; // returns false if robot still hasn't reached its goal yet
}
} // end driveStraight
// aligns robot for shooting
public void alignToShoot(double left, double right) {
Preferences p = Preferences.getInstance();
final double kShootLimitVoltage = p.getDouble("DriveTrainShootLimitVoltage", 0.0);
double maxVoltage = ultraDist.getVoltage();
for (int i = 0; i < 10; i++) {
double voltage = ultraDist.getVoltage();
if (voltage > maxVoltage) {
maxVoltage = voltage;
}
}
SmartDashboard.putNumber(
"RangefinderVoltage", maxVoltage); // want to see on competition dashboard!!
System.out.println(
"RangefinderVoltage: " + maxVoltage + " kShootLimitVoltage: " + kShootLimitVoltage);
if (maxVoltage <= kShootLimitVoltage) {
hasBeenAchieved = true;
}
if (left <= 0.0 && hasBeenAchieved) {
left = 0.0;
}
arcadeDrive(left, right);
} // end alignToShoot
// Initialize your subsystem here
public LoaderClimberOld2PID() {
// BEGIN AUTOGENERATED CODE, SOURCE=ROBOTBUILDER ID=PID
// super("LoaderClimberOld2PID", 1.5, 0.1, 0.0);
// setAbsoluteTolerance(0.02);
// getPIDController().setContinuous(false);
// END AUTOGENERATED CODE, SOURCE=ROBOTBUILDER ID=PID
m_preferences = Preferences.getInstance();
if (leftJag != null) { // for practice robot
// Fix for motors going in opposite directios
PIDOutput rightOutput =
new PIDOutput() {
public void pidWrite(double output) {
rightJag.pidWrite(-1 * output);
}
};
pidLeft = new PIDController(P, I, D, leftAngleCh, leftJag); // PID Output Interface
pidRight = new PIDController(P, I, D, rightAngleCh, rightOutput); // PID Output Interface*/
LiveWindow.addActuator("LoaderClimber", "PIDLeft Angle Controller", pidLeft);
LiveWindow.addActuator("LoaderClimber", "PIDLeft Angle Controller", pidRight);
pidLeft.setSetpoint(m_preferences.getFloat("Retract", 2.4f));
pidRight.setSetpoint(m_preferences.getFloat("RetractR", 2.4f));
pidLeft.setInputRange(0, 4);
pidRight.setInputRange(0, 4);
pidLeft.setPercentTolerance(PID_TOL);
pidRight.setPercentTolerance(PID_TOL);
pidLeft.enable(); // - Enables the PID controller.
pidRight.enable(); // - Enables the PID controller.
// disable();
}
}
public boolean quickTurn(double setpoint) {
// Proportional quickturn algorithm
Preferences p = Preferences.getInstance();
final double kP = p.getDouble("DriveTrainQuickTurnP", 0.0);
final double kDB = p.getDouble("DriveTrainQuickTurnDeadband", 0.0);
double angle = -getGyro(); // -driveTrain.getGyro() b/c the gyro is upsidedown
double error = setpoint - angle;
double twist = error * kP;
double magnitude = Math.abs(twist);
if (magnitude < kDB) {
twist = kDB * (twist > 0.0 ? 1.0 : -1.0);
} else if (magnitude > 1.0) {
twist = (twist > 0.0 ? 1.0 : -1.0);
}
SmartDashboard.putNumber("DriveTrainGyro", angle);
leftMotor.set(-twist);
rightMotor.set(twist);
// Done once we pass the setpoint
return Math.abs(angle) >= Math.abs(setpoint);
} // end quickTurn
/** Constructor init fields. */
public Benzene() {
listeningThread = new ListeningThread(this);
addController(SpecificRouting.class, defaultRouter);
preferences = Preferences.getInstance();
}
public void showNotifications(List<String> contacts) {
if (!(ActivityMonitor.getInstance().getCurrentActivity() instanceof ConversationsActivity)) {
Conversation[] conversations =
Database.getInstance(applicationContext).getConversations(preferences.getDid());
for (Conversation conversation : conversations) {
if (!conversation.isUnread()
|| !contacts.contains(conversation.getContact())
|| (ActivityMonitor.getInstance().getCurrentActivity() instanceof ConversationActivity
&& ((ConversationActivity) ActivityMonitor.getInstance().getCurrentActivity())
.getContact()
.equals(conversation.getContact()))) {
continue;
}
String smsContact = Utils.getContactName(applicationContext, conversation.getContact());
if (smsContact == null) {
smsContact = Utils.getFormattedPhoneNumber(conversation.getContact());
}
String allSmses = "";
String mostRecentSms = "";
boolean initial = true;
for (Message message : conversation.getMessages()) {
if (message.getType() == Message.Type.INCOMING && message.isUnread()) {
if (initial) {
allSmses = message.getText();
mostRecentSms = message.getText();
initial = false;
} else {
allSmses = message.getText() + "\n" + allSmses;
}
} else {
break;
}
}
NotificationCompat.Builder notificationBuilder =
new NotificationCompat.Builder(applicationContext);
notificationBuilder.setContentTitle(smsContact);
notificationBuilder.setContentText(mostRecentSms);
notificationBuilder.setSmallIcon(R.drawable.ic_chat_white_24dp);
notificationBuilder.setPriority(Notification.PRIORITY_HIGH);
notificationBuilder.setSound(
Uri.parse(Preferences.getInstance(applicationContext).getNotificationSound()));
notificationBuilder.setLights(0xFFAA0000, 1000, 5000);
if (Preferences.getInstance(applicationContext).getNotificationVibrateEnabled()) {
notificationBuilder.setVibrate(new long[] {0, 250, 250, 250});
} else {
notificationBuilder.setVibrate(new long[] {0});
}
notificationBuilder.setColor(0xFFAA0000);
notificationBuilder.setAutoCancel(true);
notificationBuilder.setStyle(new NotificationCompat.BigTextStyle().bigText(allSmses));
Bitmap largeIconBitmap;
try {
largeIconBitmap =
MediaStore.Images.Media.getBitmap(
applicationContext.getContentResolver(),
Uri.parse(
Utils.getContactPhotoUri(applicationContext, conversation.getContact())));
largeIconBitmap = Bitmap.createScaledBitmap(largeIconBitmap, 256, 256, false);
largeIconBitmap = Utils.applyCircularMask(largeIconBitmap);
notificationBuilder.setLargeIcon(largeIconBitmap);
} catch (Exception ignored) {
}
Intent intent = new Intent(applicationContext, ConversationActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
intent.putExtra(
applicationContext.getString(R.string.conversation_extra_contact),
conversation.getContact());
TaskStackBuilder stackBuilder = TaskStackBuilder.create(applicationContext);
stackBuilder.addParentStack(ConversationActivity.class);
stackBuilder.addNextIntent(intent);
notificationBuilder.setContentIntent(
stackBuilder.getPendingIntent(0, PendingIntent.FLAG_CANCEL_CURRENT));
Intent replyIntent = new Intent(applicationContext, ConversationQuickReplyActivity.class);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
replyIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_DOCUMENT);
} else {
//noinspection deprecation
replyIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
}
replyIntent.putExtra(
applicationContext.getString(R.string.conversation_extra_contact),
conversation.getContact());
PendingIntent replyPendingIntent =
PendingIntent.getActivity(
applicationContext, 0, replyIntent, PendingIntent.FLAG_CANCEL_CURRENT);
NotificationCompat.Action.Builder replyAction =
new NotificationCompat.Action.Builder(
R.drawable.ic_reply_white_24dp,
applicationContext.getString(R.string.notifications_button_reply),
replyPendingIntent);
notificationBuilder.addAction(replyAction.build());
Intent markAsReadIntent = new Intent(applicationContext, MarkAsReadReceiver.class);
markAsReadIntent.putExtra(
applicationContext.getString(R.string.conversation_extra_contact),
conversation.getContact());
PendingIntent markAsReadPendingIntent =
PendingIntent.getBroadcast(
applicationContext, 0, markAsReadIntent, PendingIntent.FLAG_CANCEL_CURRENT);
NotificationCompat.Action.Builder markAsReadAction =
new NotificationCompat.Action.Builder(
R.drawable.ic_drafts_white_24dp,
applicationContext.getString(R.string.notifications_button_mark_read),
markAsReadPendingIntent);
notificationBuilder.addAction(markAsReadAction.build());
int id;
if (notificationIds.get(conversation.getContact()) != null) {
id = notificationIds.get(conversation.getContact());
} else {
id = notificationIdCount++;
notificationIds.put(conversation.getContact(), id);
}
NotificationManager notificationManager =
(NotificationManager) applicationContext.getSystemService(Context.NOTIFICATION_SERVICE);
notificationManager.notify(id, notificationBuilder.build());
}
}
}
public void paint(Graphics g) {
int width = getSize().width;
int height = getSize().height;
offImage = createImage(width, height);
offGraphics = offImage.getGraphics();
offGraphics.setFont(font);
fm = offGraphics.getFontMetrics(font);
int xPen = 0;
int yPen = 0;
DateFormatSymbols dfs = new DateFormatSymbols(Preferences.getInstance().getLocale());
// Nom du mois
if (drawMonthName) {
String strMonthName =
StringUtil.capitalize(dfs.getMonths()[mois]) + ", " + new Integer(annee).toString();
offGraphics.setColor(BG_MONTH_NAME);
offGraphics.fillRect(xPen, yPen, (width - 1), fm.getHeight() + 2);
offGraphics.setColor(FG_MONTH_NAME);
offGraphics.drawString(strMonthName, xPen + 5, fm.getHeight());
yPen += fm.getHeight() + 2;
}
int caseWidth = (width - 2) / 7;
// Nom des jours
offGraphics.setColor(BG_DAY_NAME);
offGraphics.fillRect(1, yPen, width - 2, fm.getHeight() + 5);
offGraphics.setColor(FG_DAY_NAME);
for (int i = 1; i <= 7; i++) {
String strNomJour = StringUtil.capitalize(dfs.getWeekdays()[i].substring(0, 1));
int x = 1 + (i - 1) * caseWidth + (caseWidth - fm.stringWidth(strNomJour)) / 2;
int y = yPen + fm.getHeight() - 1;
offGraphics.drawString(strNomJour, x, y);
}
yPen += fm.getHeight() + 5;
// Cases des jours
Rectangle r = new Rectangle(1, yPen, width - 2, height - yPen - 1);
offGraphics.setFont(font);
fm = offGraphics.getFontMetrics(font);
offGraphics.setColor(BG_DAY);
offGraphics.fillRect(r.x, r.y, r.width, r.height);
int caseHeight = r.height / 7;
Calendar cal = Calendar.getInstance();
cal.setTime(dateDebutMois);
int nbJoursVides = cal.get(Calendar.DAY_OF_WEEK) - 1;
int iJoursVides = 0;
// int iJour = 1;
yPen += 3;
for (int iRow = 0; iRow < 6; iRow++) {
for (int iCol = 0; iCol < 7; iCol++) {
int day = cal.get(Calendar.DATE);
if (iJoursVides < nbJoursVides) iJoursVides++;
else if (cal.get(Calendar.MONTH) == mois) {
String strDay = (new Integer(day)).toString();
int xCase = 3 + (iCol * caseWidth);
int yCase = yPen + (iRow * caseHeight);
int x = xCase + (caseWidth - fm.stringWidth(strDay)) / 2;
// int y = yCase + ( caseHeight - fm.getHeight() ) / 2 + fm.getHeight();
int y = yCase + (caseHeight - fm.getHeight()) / 2 + fm.getHeight() - 2;
offGraphics.setFont(font);
offGraphics.setColor(FG_DAY);
// Selection
if ((iRow == selectedRow) && (iCol == selectedCol)) {
offGraphics.setColor(SELECTION_COLOR);
offGraphics.drawRect(xCase + 2, yCase + 1, caseWidth - 4, caseHeight);
offGraphics.setColor(FG_DAY);
}
offGraphics.drawString(strDay, x, y);
int dayTemp = cal.get(Calendar.DATE);
cal.add(Calendar.DATE, 1);
while (cal.get(Calendar.DATE) == dayTemp) {
// Cette boucle inefficace est la pour contrer le probleme de l'heure avancee
cal.add(Calendar.MINUTE, 1);
}
}
}
}
// Cadre
offGraphics.setColor(Color.black);
offGraphics.drawRect(0, 0, width - 1, height - 6);
g.drawImage(offImage, 0, 5, null);
}
